Branch data Line data Source code
1 : : /* Implementation of Fortran 2003 Polymorphism.
2 : : Copyright (C) 2009-2025 Free Software Foundation, Inc.
3 : : Contributed by Paul Richard Thomas <pault@gcc.gnu.org>
4 : : and Janus Weil <janus@gcc.gnu.org>
5 : :
6 : : This file is part of GCC.
7 : :
8 : : GCC is free software; you can redistribute it and/or modify it under
9 : : the terms of the GNU General Public License as published by the Free
10 : : Software Foundation; either version 3, or (at your option) any later
11 : : version.
12 : :
13 : : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 : : WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 : : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 : : for more details.
17 : :
18 : : You should have received a copy of the GNU General Public License
19 : : along with GCC; see the file COPYING3. If not see
20 : : <http://www.gnu.org/licenses/>. */
21 : :
22 : :
23 : : /* class.cc -- This file contains the front end functions needed to service
24 : : the implementation of Fortran 2003 polymorphism and other
25 : : object-oriented features. */
26 : :
27 : :
28 : : /* Outline of the internal representation:
29 : :
30 : : Each CLASS variable is encapsulated by a class container, which is a
31 : : structure with two fields:
32 : : * _data: A pointer to the actual data of the variable. This field has the
33 : : declared type of the class variable and its attributes
34 : : (pointer/allocatable/dimension/...).
35 : : * _vptr: A pointer to the vtable entry (see below) of the dynamic type.
36 : :
37 : : Only for unlimited polymorphic classes:
38 : : * _len: An integer(C_SIZE_T) to store the string length when the unlimited
39 : : polymorphic pointer is used to point to a char array. The '_len'
40 : : component will be zero when no character array is stored in
41 : : '_data'.
42 : :
43 : : For each derived type we set up a "vtable" entry, i.e. a structure with the
44 : : following fields:
45 : : * _hash: A hash value serving as a unique identifier for this type.
46 : : * _size: The size in bytes of the derived type.
47 : : * _extends: A pointer to the vtable entry of the parent derived type.
48 : : * _def_init: A pointer to a default initialized variable of this type.
49 : : * _copy: A procedure pointer to a copying procedure.
50 : : * _final: A procedure pointer to a wrapper function, which frees
51 : : allocatable components and calls FINAL subroutines.
52 : : * _deallocate: A procedure pointer to a deallocation procedure; nonnull
53 : : only for a recursive derived type.
54 : :
55 : : After these follow procedure pointer components for the specific
56 : : type-bound procedures. */
57 : :
58 : :
59 : : #include "config.h"
60 : : #include "system.h"
61 : : #include "coretypes.h"
62 : : #include "gfortran.h"
63 : : #include "constructor.h"
64 : : #include "target-memory.h"
65 : :
66 : : /* Inserts a derived type component reference in a data reference chain.
67 : : TS: base type of the ref chain so far, in which we will pick the component
68 : : REF: the address of the GFC_REF pointer to update
69 : : NAME: name of the component to insert
70 : : Note that component insertion makes sense only if we are at the end of
71 : : the chain (*REF == NULL) or if we are adding a missing "_data" component
72 : : to access the actual contents of a class object. */
73 : :
74 : : static void
75 : 11052 : insert_component_ref (gfc_typespec *ts, gfc_ref **ref, const char * const name)
76 : : {
77 : 11052 : gfc_ref *new_ref;
78 : 11052 : int wcnt, ecnt;
79 : :
80 : 11052 : gcc_assert (ts->type == BT_DERIVED || ts->type == BT_CLASS);
81 : :
82 : 11052 : gfc_find_component (ts->u.derived, name, true, true, &new_ref);
83 : :
84 : 11052 : gfc_get_errors (&wcnt, &ecnt);
85 : 11052 : if (ecnt > 0 && !new_ref)
86 : 1 : return;
87 : 11051 : gcc_assert (new_ref->u.c.component);
88 : :
89 : 11051 : while (new_ref->next)
90 : 0 : new_ref = new_ref->next;
91 : 11051 : new_ref->next = *ref;
92 : :
93 : 11051 : if (new_ref->next)
94 : : {
95 : 11051 : gfc_ref *next = NULL;
96 : :
97 : : /* We need to update the base type in the trailing reference chain to
98 : : that of the new component. */
99 : :
100 : 11051 : gcc_assert (strcmp (name, "_data") == 0);
101 : :
102 : 11051 : if (new_ref->next->type == REF_COMPONENT)
103 : : next = new_ref->next;
104 : 10522 : else if (new_ref->next->type == REF_ARRAY
105 : 10522 : && new_ref->next->next
106 : 2137 : && new_ref->next->next->type == REF_COMPONENT)
107 : : next = new_ref->next->next;
108 : :
109 : 2597 : if (next != NULL)
110 : : {
111 : 2597 : gcc_assert (new_ref->u.c.component->ts.type == BT_CLASS
112 : : || new_ref->u.c.component->ts.type == BT_DERIVED);
113 : 2597 : next->u.c.sym = new_ref->u.c.component->ts.u.derived;
114 : : }
115 : : }
116 : :
117 : 11051 : *ref = new_ref;
118 : : }
119 : :
120 : :
121 : : /* Tells whether we need to add a "_data" reference to access REF subobject
122 : : from an object of type TS. If FIRST_REF_IN_CHAIN is set, then the base
123 : : object accessed by REF is a variable; in other words it is a full object,
124 : : not a subobject. */
125 : :
126 : : static bool
127 : 1176860 : class_data_ref_missing (gfc_typespec *ts, gfc_ref *ref, bool first_ref_in_chain)
128 : : {
129 : : /* Only class containers may need the "_data" reference. */
130 : 1176860 : if (ts->type != BT_CLASS)
131 : : return false;
132 : :
133 : : /* Accessing a class container with an array reference is certainly wrong. */
134 : 101605 : if (ref->type != REF_COMPONENT)
135 : : return true;
136 : :
137 : : /* Accessing the class container's fields is fine. */
138 : 91082 : if (ref->u.c.component->name[0] == '_')
139 : : return false;
140 : :
141 : : /* At this point we have a class container with a non class container's field
142 : : component reference. We don't want to add the "_data" component if we are
143 : : at the first reference and the symbol's type is an extended derived type.
144 : : In that case, conv_parent_component_references will do the right thing so
145 : : it is not absolutely necessary. Omitting it prevents a regression (see
146 : : class_41.f03) in the interface mapping mechanism. When evaluating string
147 : : lengths depending on dummy arguments, we create a fake symbol with a type
148 : : equal to that of the dummy type. However, because of type extension,
149 : : the backend type (corresponding to the actual argument) can have a
150 : : different (extended) type. Adding the "_data" component explicitly, using
151 : : the base type, confuses the gfc_conv_component_ref code which deals with
152 : : the extended type. */
153 : 12764 : if (first_ref_in_chain && ts->u.derived->attr.extension)
154 : 12235 : return false;
155 : :
156 : : /* We have a class container with a non class container's field component
157 : : reference that doesn't fall into the above. */
158 : : return true;
159 : : }
160 : :
161 : :
162 : : /* Browse through a data reference chain and add the missing "_data" references
163 : : when a subobject of a class object is accessed without it.
164 : : Note that it doesn't add the "_data" reference when the class container
165 : : is the last element in the reference chain. */
166 : :
167 : : void
168 : 4060704 : gfc_fix_class_refs (gfc_expr *e)
169 : : {
170 : 4060704 : gfc_typespec *ts;
171 : 4060704 : gfc_ref **ref;
172 : :
173 : 4060704 : if ((e->expr_type != EXPR_VARIABLE
174 : 1895351 : && e->expr_type != EXPR_FUNCTION)
175 : 2444993 : || (e->expr_type == EXPR_FUNCTION
176 : 279640 : && e->value.function.isym != NULL))
177 : : return;
178 : :
179 : 2213869 : if (e->expr_type == EXPR_VARIABLE)
180 : 2165353 : ts = &e->symtree->n.sym->ts;
181 : : else
182 : : {
183 : 48516 : gfc_symbol *func;
184 : :
185 : 48516 : gcc_assert (e->expr_type == EXPR_FUNCTION);
186 : 48516 : if (e->value.function.esym != NULL)
187 : : func = e->value.function.esym;
188 : : else
189 : 1438 : func = e->symtree->n.sym;
190 : :
191 : 48516 : if (func->result != NULL)
192 : 47390 : ts = &func->result->ts;
193 : : else
194 : 1126 : ts = &func->ts;
195 : : }
196 : :
197 : 3390729 : for (ref = &e->ref; *ref != NULL; ref = &(*ref)->next)
198 : : {
199 : 1176860 : if (class_data_ref_missing (ts, *ref, ref == &e->ref))
200 : 11052 : insert_component_ref (ts, ref, "_data");
201 : :
202 : 1176860 : if ((*ref)->type == REF_COMPONENT)
203 : 239959 : ts = &(*ref)->u.c.component->ts;
204 : : }
205 : : }
206 : :
207 : :
208 : : /* Insert a reference to the component of the given name.
209 : : Only to be used with CLASS containers and vtables. */
210 : :
211 : : void
212 : 57038 : gfc_add_component_ref (gfc_expr *e, const char *name)
213 : : {
214 : 57038 : gfc_component *c;
215 : 57038 : gfc_ref **tail = &(e->ref);
216 : 57038 : gfc_ref *ref, *next = NULL;
217 : 57038 : gfc_symbol *derived = e->symtree->n.sym->ts.u.derived;
218 : 81425 : while (*tail != NULL)
219 : : {
220 : 38571 : if ((*tail)->type == REF_COMPONENT)
221 : : {
222 : 23506 : if (strcmp ((*tail)->u.c.component->name, "_data") == 0
223 : 1337 : && (*tail)->next
224 : 1337 : && (*tail)->next->type == REF_ARRAY
225 : 1253 : && (*tail)->next->next == NULL)
226 : : return;
227 : 22511 : derived = (*tail)->u.c.component->ts.u.derived;
228 : : }
229 : 37576 : if ((*tail)->type == REF_ARRAY && (*tail)->next == NULL)
230 : : break;
231 : 24387 : tail = &((*tail)->next);
232 : : }
233 : 56043 : if (derived && derived->components && derived->components->next &&
234 : 56037 : derived->components->next->ts.type == BT_DERIVED &&
235 : 43384 : derived->components->next->ts.u.derived == NULL)
236 : : {
237 : : /* Fix up missing vtype. */
238 : 19 : gfc_symbol *vtab = gfc_find_derived_vtab (derived->components->ts.u.derived);
239 : 19 : gcc_assert (vtab);
240 : 19 : derived->components->next->ts.u.derived = vtab->ts.u.derived;
241 : : }
242 : 56043 : if (*tail != NULL && strcmp (name, "_data") == 0)
243 : : next = *tail;
244 : : else
245 : : /* Avoid losing memory. */
246 : 48433 : gfc_free_ref_list (*tail);
247 : 56043 : c = gfc_find_component (derived, name, true, true, tail);
248 : :
249 : 56043 : if (c) {
250 : 56036 : for (ref = *tail; ref->next; ref = ref->next)
251 : : ;
252 : 56036 : ref->next = next;
253 : 56036 : if (!next)
254 : 48426 : e->ts = c->ts;
255 : : }
256 : : }
257 : :
258 : :
259 : : /* This is used to add both the _data component reference and an array
260 : : reference to class expressions. Used in translation of intrinsic
261 : : array inquiry functions. */
262 : :
263 : : void
264 : 4627 : gfc_add_class_array_ref (gfc_expr *e)
265 : : {
266 : 4627 : int rank = CLASS_DATA (e)->as->rank;
267 : 4627 : int corank = CLASS_DATA (e)->as->corank;
268 : 4627 : gfc_array_spec *as = CLASS_DATA (e)->as;
269 : 4627 : gfc_ref *ref = NULL;
270 : 4627 : gfc_add_data_component (e);
271 : 4627 : e->rank = rank;
272 : 4627 : e->corank = corank;
273 : 8891 : for (ref = e->ref; ref; ref = ref->next)
274 : 8891 : if (!ref->next)
275 : : break;
276 : 4627 : if (ref->type != REF_ARRAY)
277 : : {
278 : 1103 : ref->next = gfc_get_ref ();
279 : 1103 : ref = ref->next;
280 : 1103 : ref->type = REF_ARRAY;
281 : 1103 : ref->u.ar.type = AR_FULL;
282 : 1103 : ref->u.ar.as = as;
283 : : }
284 : 4627 : }
285 : :
286 : :
287 : : /* Unfortunately, class array expressions can appear in various conditions;
288 : : with and without both _data component and an arrayspec. This function
289 : : deals with that variability. The previous reference to 'ref' is to a
290 : : class array. */
291 : :
292 : : static bool
293 : 7006 : class_array_ref_detected (gfc_ref *ref, bool *full_array)
294 : : {
295 : 7006 : bool no_data = false;
296 : 7006 : bool with_data = false;
297 : :
298 : : /* An array reference with no _data component. */
299 : 7006 : if (ref && ref->type == REF_ARRAY
300 : 444 : && !ref->next
301 : 444 : && ref->u.ar.type != AR_ELEMENT)
302 : : {
303 : 444 : if (full_array)
304 : 444 : *full_array = ref->u.ar.type == AR_FULL;
305 : 444 : no_data = true;
306 : : }
307 : :
308 : : /* Cover cases where _data appears, with or without an array ref. */
309 : 7425 : if (ref && ref->type == REF_COMPONENT
310 : 6537 : && strcmp (ref->u.c.component->name, "_data") == 0)
311 : : {
312 : 6531 : if (!ref->next)
313 : : {
314 : 0 : with_data = true;
315 : 0 : if (full_array)
316 : 0 : *full_array = true;
317 : : }
318 : 6531 : else if (ref->next && ref->next->type == REF_ARRAY
319 : : && ref->type == REF_COMPONENT
320 : 6531 : && ref->next->u.ar.type != AR_ELEMENT)
321 : : {
322 : 6141 : with_data = true;
323 : 6141 : if (full_array)
324 : 2715 : *full_array = ref->next->u.ar.type == AR_FULL;
325 : : }
326 : : }
327 : :
328 : 7006 : return no_data || with_data;
329 : : }
330 : :
331 : :
332 : : /* Returns true if the expression contains a reference to a class
333 : : array. Notice that class array elements return false. */
334 : :
335 : : bool
336 : 253529 : gfc_is_class_array_ref (gfc_expr *e, bool *full_array)
337 : : {
338 : 253529 : gfc_ref *ref;
339 : :
340 : 253529 : if (!e->rank)
341 : : return false;
342 : :
343 : 220361 : if (full_array)
344 : 3183 : *full_array= false;
345 : :
346 : : /* Is this a class array object? ie. Is the symbol of type class? */
347 : 220361 : if (e->symtree
348 : 178363 : && e->symtree->n.sym->ts.type == BT_CLASS
349 : 6680 : && CLASS_DATA (e->symtree->n.sym)
350 : 6680 : && CLASS_DATA (e->symtree->n.sym)->attr.dimension
351 : 226191 : && class_array_ref_detected (e->ref, full_array))
352 : : return true;
353 : :
354 : : /* Or is this a class array component reference? */
355 : 394066 : for (ref = e->ref; ref; ref = ref->next)
356 : : {
357 : 180290 : if (ref->type == REF_COMPONENT
358 : 16457 : && ref->u.c.component->ts.type == BT_CLASS
359 : 1322 : && CLASS_DATA (ref->u.c.component)->attr.dimension
360 : 181466 : && class_array_ref_detected (ref->next, full_array))
361 : : return true;
362 : : }
363 : :
364 : : return false;
365 : : }
366 : :
367 : :
368 : : /* Returns true if the expression is a reference to a class
369 : : scalar. This function is necessary because such expressions
370 : : can be dressed with a reference to the _data component and so
371 : : have a type other than BT_CLASS. */
372 : :
373 : : bool
374 : 41896 : gfc_is_class_scalar_expr (gfc_expr *e)
375 : : {
376 : 41896 : gfc_ref *ref;
377 : :
378 : 41896 : if (e->rank)
379 : : return false;
380 : :
381 : : /* Is this a class object? */
382 : 37020 : if (e->symtree && e->symtree->n.sym->ts.type == BT_CLASS
383 : 1956 : && CLASS_DATA (e->symtree->n.sym)
384 : 1956 : && !CLASS_DATA (e->symtree->n.sym)->attr.dimension
385 : 1710 : && (e->ref == NULL
386 : 1315 : || (e->ref->type == REF_COMPONENT
387 : 1313 : && strcmp (e->ref->u.c.component->name, "_data") == 0
388 : 1016 : && (e->ref->next == NULL
389 : 31 : || (e->ref->next->type == REF_ARRAY
390 : 31 : && e->ref->next->u.ar.codimen > 0
391 : 31 : && e->ref->next->u.ar.dimen == 0
392 : 31 : && e->ref->next->next == NULL)))))
393 : : return true;
394 : :
395 : : /* Or is the final reference BT_CLASS or _data? */
396 : 38442 : for (ref = e->ref; ref; ref = ref->next)
397 : : {
398 : 3282 : if (ref->type == REF_COMPONENT && ref->u.c.component->ts.type == BT_CLASS
399 : 565 : && CLASS_DATA (ref->u.c.component)
400 : 565 : && !CLASS_DATA (ref->u.c.component)->attr.dimension
401 : 499 : && (ref->next == NULL
402 : 367 : || (ref->next->type == REF_COMPONENT
403 : 365 : && strcmp (ref->next->u.c.component->name, "_data") == 0
404 : 365 : && (ref->next->next == NULL
405 : 42 : || (ref->next->next->type == REF_ARRAY
406 : 6 : && ref->next->next->u.ar.codimen > 0
407 : 6 : && ref->next->next->u.ar.dimen == 0
408 : 6 : && ref->next->next->next == NULL)))))
409 : : return true;
410 : : }
411 : :
412 : : return false;
413 : : }
414 : :
415 : :
416 : : /* Tells whether the expression E is a reference to a (scalar) class container.
417 : : Scalar because array class containers usually have an array reference after
418 : : them, and gfc_fix_class_refs will add the missing "_data" component reference
419 : : in that case. */
420 : :
421 : : bool
422 : 1340 : gfc_is_class_container_ref (gfc_expr *e)
423 : : {
424 : 1340 : gfc_ref *ref;
425 : 1340 : bool result;
426 : :
427 : 1340 : if (e->expr_type != EXPR_VARIABLE)
428 : 230 : return e->ts.type == BT_CLASS;
429 : :
430 : 1110 : if (e->symtree->n.sym->ts.type == BT_CLASS)
431 : : result = true;
432 : : else
433 : 888 : result = false;
434 : :
435 : 2409 : for (ref = e->ref; ref; ref = ref->next)
436 : : {
437 : 1299 : if (ref->type != REF_COMPONENT)
438 : : result = false;
439 : 289 : else if (ref->u.c.component->ts.type == BT_CLASS)
440 : : result = true;
441 : : else
442 : 1299 : result = false;
443 : : }
444 : :
445 : : return result;
446 : : }
447 : :
448 : :
449 : : /* Build an initializer for CLASS pointers,
450 : : initializing the _data component to the init_expr (or NULL) and the _vptr
451 : : component to the corresponding type (or the declared type, given by ts). */
452 : :
453 : : gfc_expr *
454 : 3288 : gfc_class_initializer (gfc_typespec *ts, gfc_expr *init_expr)
455 : : {
456 : 3288 : gfc_expr *init;
457 : 3288 : gfc_component *comp;
458 : 3288 : gfc_symbol *vtab = NULL;
459 : :
460 : 3288 : if (init_expr && init_expr->expr_type != EXPR_NULL)
461 : 1622 : vtab = gfc_find_vtab (&init_expr->ts);
462 : : else
463 : 1666 : vtab = gfc_find_vtab (ts);
464 : :
465 : 6576 : init = gfc_get_structure_constructor_expr (ts->type, ts->kind,
466 : 3288 : &ts->u.derived->declared_at);
467 : 3288 : init->ts = *ts;
468 : :
469 : 10345 : for (comp = ts->u.derived->components; comp; comp = comp->next)
470 : : {
471 : 7057 : gfc_constructor *ctor = gfc_constructor_get();
472 : 7057 : if (strcmp (comp->name, "_vptr") == 0 && vtab)
473 : 3288 : ctor->expr = gfc_lval_expr_from_sym (vtab);
474 : 3769 : else if (init_expr && init_expr->expr_type != EXPR_NULL)
475 : 1845 : ctor->expr = gfc_copy_expr (init_expr);
476 : : else
477 : 1924 : ctor->expr = gfc_get_null_expr (NULL);
478 : 7057 : gfc_constructor_append (&init->value.constructor, ctor);
479 : : }
480 : :
481 : 3288 : return init;
482 : : }
483 : :
484 : :
485 : : /* Create a unique string identifier for a derived type, composed of its name
486 : : and module name. This is used to construct unique names for the class
487 : : containers and vtab symbols. */
488 : :
489 : : static char *
490 : 100130 : get_unique_type_string (gfc_symbol *derived)
491 : : {
492 : 100130 : const char *dt_name;
493 : 100130 : char *string;
494 : 100130 : size_t len;
495 : 100130 : if (derived->attr.unlimited_polymorphic)
496 : : dt_name = "STAR";
497 : : else
498 : 93465 : dt_name = gfc_dt_upper_string (derived->name);
499 : 100130 : len = strlen (dt_name) + 2;
500 : 100130 : if (derived->attr.unlimited_polymorphic)
501 : : {
502 : 6665 : string = XNEWVEC (char, len);
503 : 6665 : sprintf (string, "_%s", dt_name);
504 : : }
505 : 93465 : else if (derived->module)
506 : : {
507 : 37287 : string = XNEWVEC (char, strlen (derived->module) + len);
508 : 37287 : sprintf (string, "%s_%s", derived->module, dt_name);
509 : : }
510 : 56178 : else if (derived->ns->proc_name)
511 : : {
512 : 55397 : string = XNEWVEC (char, strlen (derived->ns->proc_name->name) + len);
513 : 55397 : sprintf (string, "%s_%s", derived->ns->proc_name->name, dt_name);
514 : : }
515 : : else
516 : : {
517 : 781 : string = XNEWVEC (char, len);
518 : 781 : sprintf (string, "_%s", dt_name);
519 : : }
520 : 100130 : return string;
521 : : }
522 : :
523 : :
524 : : /* A relative of 'get_unique_type_string' which makes sure the generated
525 : : string will not be too long (replacing it by a hash string if needed). */
526 : :
527 : : static void
528 : 86311 : get_unique_hashed_string (char *string, gfc_symbol *derived)
529 : : {
530 : : /* Provide sufficient space to hold "symbol.symbol_symbol". */
531 : 86311 : char *tmp;
532 : 86311 : tmp = get_unique_type_string (derived);
533 : : /* If string is too long, use hash value in hex representation (allow for
534 : : extra decoration, cf. gfc_build_class_symbol & gfc_find_derived_vtab).
535 : : We need space to for 15 characters "__class_" + symbol name + "_%d_%da",
536 : : where %d is the (co)rank which can be up to n = 15. */
537 : 86311 : if (strlen (tmp) > GFC_MAX_SYMBOL_LEN - 15)
538 : : {
539 : 133 : int h = gfc_hash_value (derived);
540 : 133 : sprintf (string, "%X", h);
541 : : }
542 : : else
543 : 86178 : strcpy (string, tmp);
544 : 86311 : free (tmp);
545 : 86311 : }
546 : :
547 : :
548 : : /* Assign a hash value for a derived type. The algorithm is that of SDBM. */
549 : :
550 : : unsigned int
551 : 13819 : gfc_hash_value (gfc_symbol *sym)
552 : : {
553 : 13819 : unsigned int hash = 0;
554 : : /* Provide sufficient space to hold "symbol.symbol_symbol". */
555 : 13819 : char *c;
556 : 13819 : int i, len;
557 : :
558 : 13819 : c = get_unique_type_string (sym);
559 : 13819 : len = strlen (c);
560 : :
561 : 215376 : for (i = 0; i < len; i++)
562 : 201557 : hash = (hash << 6) + (hash << 16) - hash + c[i];
563 : :
564 : 13819 : free (c);
565 : : /* Return the hash but take the modulus for the sake of module read,
566 : : even though this slightly increases the chance of collision. */
567 : 13819 : return (hash % 100000000);
568 : : }
569 : :
570 : :
571 : : /* Assign a hash value for an intrinsic type. The algorithm is that of SDBM. */
572 : :
573 : : unsigned int
574 : 844 : gfc_intrinsic_hash_value (gfc_typespec *ts)
575 : : {
576 : 844 : unsigned int hash = 0;
577 : 844 : const char *c = gfc_typename (ts, true);
578 : 844 : int i, len;
579 : :
580 : 844 : len = strlen (c);
581 : :
582 : 9238 : for (i = 0; i < len; i++)
583 : 8394 : hash = (hash << 6) + (hash << 16) - hash + c[i];
584 : :
585 : : /* Return the hash but take the modulus for the sake of module read,
586 : : even though this slightly increases the chance of collision. */
587 : 844 : return (hash % 100000000);
588 : : }
589 : :
590 : :
591 : : /* Get the _len component from a class/derived object storing a string.
592 : : For unlimited polymorphic entities a ref to the _data component is available
593 : : while a ref to the _len component is needed. This routine traverese the
594 : : ref-chain and strips the last ref to a _data from it replacing it with a
595 : : ref to the _len component. */
596 : :
597 : : gfc_expr *
598 : 367 : gfc_get_len_component (gfc_expr *e, int k)
599 : : {
600 : 367 : gfc_expr *ptr;
601 : 367 : gfc_ref *ref, **last;
602 : :
603 : 367 : ptr = gfc_copy_expr (e);
604 : :
605 : : /* We need to remove the last _data component ref from ptr. */
606 : 367 : last = &(ptr->ref);
607 : 367 : ref = ptr->ref;
608 : 367 : while (ref)
609 : : {
610 : 367 : if (!ref->next
611 : 367 : && ref->type == REF_COMPONENT
612 : 367 : && strcmp ("_data", ref->u.c.component->name)== 0)
613 : : {
614 : 367 : gfc_free_ref_list (ref);
615 : 367 : *last = NULL;
616 : 367 : break;
617 : : }
618 : 0 : last = &(ref->next);
619 : 0 : ref = ref->next;
620 : : }
621 : : /* And replace if with a ref to the _len component. */
622 : 367 : gfc_add_len_component (ptr);
623 : 367 : if (k != ptr->ts.kind)
624 : : {
625 : 367 : gfc_typespec ts;
626 : 367 : gfc_clear_ts (&ts);
627 : 367 : ts.type = BT_INTEGER;
628 : 367 : ts.kind = k;
629 : 367 : gfc_convert_type_warn (ptr, &ts, 2, 0);
630 : : }
631 : 367 : return ptr;
632 : : }
633 : :
634 : :
635 : : /* Build a polymorphic CLASS entity, using the symbol that comes from
636 : : build_sym. A CLASS entity is represented by an encapsulating type,
637 : : which contains the declared type as '_data' component, plus a pointer
638 : : component '_vptr' which determines the dynamic type. When this CLASS
639 : : entity is unlimited polymorphic, then also add a component '_len' to
640 : : store the length of string when that is stored in it. */
641 : : static int ctr = 0;
642 : :
643 : : bool
644 : 12440 : gfc_build_class_symbol (gfc_typespec *ts, symbol_attribute *attr,
645 : : gfc_array_spec **as)
646 : : {
647 : 12440 : char tname[GFC_MAX_SYMBOL_LEN+1];
648 : 12440 : char *name;
649 : 12440 : gfc_typespec *orig_ts = ts;
650 : 12440 : gfc_symbol *fclass;
651 : 12440 : gfc_symbol *vtab;
652 : 12440 : gfc_component *c;
653 : 12440 : gfc_namespace *ns;
654 : 12440 : int rank;
655 : :
656 : 12440 : gcc_assert (as);
657 : :
658 : : /* We cannot build the class container now. */
659 : 12440 : if (attr->class_ok && (!ts->u.derived || !ts->u.derived->components))
660 : : return false;
661 : :
662 : : /* Class container has already been built with same name. */
663 : 12439 : if (attr->class_ok
664 : 34 : && ts->u.derived->components->attr.dimension >= attr->dimension
665 : 21 : && ts->u.derived->components->attr.codimension >= attr->codimension
666 : 16 : && ts->u.derived->components->attr.class_pointer >= attr->pointer
667 : 10 : && ts->u.derived->components->attr.allocatable >= attr->allocatable)
668 : : return true;
669 : 12438 : if (attr->class_ok)
670 : : {
671 : 33 : attr->dimension |= ts->u.derived->components->attr.dimension;
672 : 33 : attr->codimension |= ts->u.derived->components->attr.codimension;
673 : 33 : attr->pointer |= ts->u.derived->components->attr.class_pointer;
674 : 33 : attr->allocatable |= ts->u.derived->components->attr.allocatable;
675 : 33 : ts = &ts->u.derived->components->ts;
676 : : }
677 : :
678 : 24876 : attr->class_ok = attr->dummy || attr->pointer || attr->allocatable
679 : 12438 : || attr->select_type_temporary || attr->associate_var;
680 : :
681 : 12438 : if (!attr->class_ok)
682 : : /* We cannot build the class container yet. */
683 : : return true;
684 : :
685 : : /* Determine the name of the encapsulating type. */
686 : 12369 : rank = !(*as) || (*as)->rank == -1 ? GFC_MAX_DIMENSIONS : (*as)->rank;
687 : :
688 : 12369 : if (!ts->u.derived)
689 : : return false;
690 : :
691 : 12364 : get_unique_hashed_string (tname, ts->u.derived);
692 : 12364 : if ((*as) && attr->allocatable)
693 : 1953 : name = xasprintf ("__class_%s_%d_%da", tname, rank, (*as)->corank);
694 : 10411 : else if ((*as) && attr->pointer)
695 : 1146 : name = xasprintf ("__class_%s_%d_%dp", tname, rank, (*as)->corank);
696 : 9265 : else if ((*as))
697 : 1133 : name = xasprintf ("__class_%s_%d_%dt", tname, rank, (*as)->corank);
698 : 8132 : else if (attr->pointer)
699 : 1720 : name = xasprintf ("__class_%s_p", tname);
700 : 6412 : else if (attr->allocatable)
701 : 2090 : name = xasprintf ("__class_%s_a", tname);
702 : : else
703 : 4322 : name = xasprintf ("__class_%s_t", tname);
704 : :
705 : 12364 : if (ts->u.derived->attr.unlimited_polymorphic)
706 : : {
707 : : /* Find the top-level namespace. */
708 : 4409 : for (ns = gfc_current_ns; ns; ns = ns->parent)
709 : 4409 : if (!ns->parent)
710 : : break;
711 : : }
712 : : else
713 : 9986 : ns = ts->u.derived->ns;
714 : :
715 : : /* Although this might seem to be counterintuitive, we can build separate
716 : : class types with different array specs because the TKR interface checks
717 : : work on the declared type. All array type other than deferred shape or
718 : : assumed rank are added to the function namespace to ensure that they
719 : : are properly distinguished. */
720 : 12364 : if (attr->dummy && (*as)
721 : 1808 : && ((!attr->codimension
722 : 1646 : && !((*as)->type == AS_DEFERRED || (*as)->type == AS_ASSUMED_RANK))
723 : 1573 : || (attr->codimension
724 : 162 : && !((*as)->cotype == AS_DEFERRED
725 : : || (*as)->cotype == AS_ASSUMED_RANK))))
726 : : {
727 : 330 : char *sname;
728 : 330 : ns = gfc_current_ns;
729 : 330 : gfc_find_symbol (name, ns, 0, &fclass);
730 : : /* If a local class type with this name already exists, update the
731 : : name with an index. */
732 : 330 : if (fclass)
733 : : {
734 : 16 : fclass = NULL;
735 : 16 : sname = xasprintf ("%s_%d", name, ++ctr);
736 : 16 : free (name);
737 : 16 : name = sname;
738 : : }
739 : : }
740 : : else
741 : 12034 : gfc_find_symbol (name, ns, 0, &fclass);
742 : :
743 : 12364 : if (fclass == NULL)
744 : : {
745 : 7505 : gfc_symtree *st;
746 : : /* If not there, create a new symbol. */
747 : 7505 : fclass = gfc_new_symbol (name, ns);
748 : 7505 : st = gfc_new_symtree (&ns->sym_root, name);
749 : 7505 : st->n.sym = fclass;
750 : 7505 : gfc_set_sym_referenced (fclass);
751 : 7505 : fclass->refs++;
752 : 7505 : fclass->ts.type = BT_UNKNOWN;
753 : 7505 : if (!ts->u.derived->attr.unlimited_polymorphic)
754 : 6021 : fclass->attr.abstract = ts->u.derived->attr.abstract;
755 : 7505 : fclass->f2k_derived = gfc_get_namespace (NULL, 0);
756 : 7505 : if (!gfc_add_flavor (&fclass->attr, FL_DERIVED, NULL,
757 : : &gfc_current_locus))
758 : : return false;
759 : :
760 : : /* Add component '_data'. */
761 : 7505 : if (!gfc_add_component (fclass, "_data", &c))
762 : : return false;
763 : 7505 : c->ts = *ts;
764 : 7505 : c->ts.type = BT_DERIVED;
765 : 7505 : c->attr.access = ACCESS_PRIVATE;
766 : 7505 : c->ts.u.derived = ts->u.derived;
767 : 7505 : c->attr.class_pointer = attr->pointer;
768 : 5872 : c->attr.pointer = attr->pointer || (attr->dummy && !attr->allocatable)
769 : 10144 : || attr->select_type_temporary;
770 : 7505 : c->attr.allocatable = attr->allocatable;
771 : 7505 : c->attr.dimension = attr->dimension;
772 : 7505 : c->attr.codimension = attr->codimension;
773 : 7505 : c->attr.abstract = fclass->attr.abstract;
774 : 7505 : c->as = (*as);
775 : 7505 : c->initializer = NULL;
776 : :
777 : : /* Add component '_vptr'. */
778 : 7505 : if (!gfc_add_component (fclass, "_vptr", &c))
779 : : return false;
780 : 7505 : c->ts.type = BT_DERIVED;
781 : 7505 : c->attr.access = ACCESS_PRIVATE;
782 : 7505 : c->attr.pointer = 1;
783 : :
784 : 7505 : if (ts->u.derived->attr.unlimited_polymorphic)
785 : : {
786 : 1484 : vtab = gfc_find_derived_vtab (ts->u.derived);
787 : 1484 : gcc_assert (vtab);
788 : 1484 : c->ts.u.derived = vtab->ts.u.derived;
789 : :
790 : : /* Add component '_len'. Only unlimited polymorphic pointers may
791 : : have a string assigned to them, i.e., only those need the _len
792 : : component. */
793 : 1484 : if (!gfc_add_component (fclass, "_len", &c))
794 : : return false;
795 : 1484 : c->ts.type = BT_INTEGER;
796 : 1484 : c->ts.kind = gfc_charlen_int_kind;
797 : 1484 : c->attr.access = ACCESS_PRIVATE;
798 : 1484 : c->attr.artificial = 1;
799 : : }
800 : : else
801 : : /* Build vtab later. */
802 : 6021 : c->ts.u.derived = NULL;
803 : : }
804 : :
805 : 12364 : if (!ts->u.derived->attr.unlimited_polymorphic)
806 : : {
807 : : /* Since the extension field is 8 bit wide, we can only have
808 : : up to 255 extension levels. */
809 : 9986 : if (ts->u.derived->attr.extension == 255)
810 : : {
811 : 0 : gfc_error ("Maximum extension level reached with type %qs at %L",
812 : : ts->u.derived->name, &ts->u.derived->declared_at);
813 : 0 : return false;
814 : : }
815 : :
816 : 9986 : fclass->attr.extension = ts->u.derived->attr.extension + 1;
817 : 9986 : fclass->attr.alloc_comp = ts->u.derived->attr.alloc_comp;
818 : 9986 : fclass->attr.coarray_comp = ts->u.derived->attr.coarray_comp;
819 : : }
820 : :
821 : 12364 : fclass->attr.is_class = 1;
822 : 12364 : orig_ts->u.derived = fclass;
823 : 12364 : attr->allocatable = attr->pointer = attr->dimension = attr->codimension = 0;
824 : 12364 : (*as) = NULL;
825 : 12364 : free (name);
826 : 12364 : return true;
827 : : }
828 : :
829 : :
830 : : /* Change class, using gfc_build_class_symbol. This is needed for associate
831 : : names, when rank changes or a derived type is produced by resolution. */
832 : :
833 : : void
834 : 109 : gfc_change_class (gfc_typespec *ts, symbol_attribute *sym_attr,
835 : : gfc_array_spec *sym_as, int rank, int corank)
836 : : {
837 : 109 : symbol_attribute attr;
838 : 109 : gfc_component *c;
839 : 109 : gfc_array_spec *as = NULL;
840 : 109 : gfc_symbol *der = ts->u.derived;
841 : :
842 : 109 : ts->type = BT_CLASS;
843 : 109 : attr = *sym_attr;
844 : 109 : attr.class_ok = 0;
845 : 109 : attr.associate_var = 1;
846 : 109 : attr.class_pointer = 1;
847 : 109 : attr.allocatable = 0;
848 : 109 : attr.pointer = 1;
849 : 109 : attr.dimension = rank ? 1 : 0;
850 : 13 : if (rank)
851 : : {
852 : 96 : if (sym_as)
853 : 18 : as = gfc_copy_array_spec (sym_as);
854 : : else
855 : : {
856 : 78 : as = gfc_get_array_spec ();
857 : 78 : as->rank = rank;
858 : 78 : as->type = AS_DEFERRED;
859 : 78 : as->corank = corank;
860 : : }
861 : : }
862 : 109 : if (as && as->corank != 0)
863 : 0 : attr.codimension = 1;
864 : :
865 : 109 : if (!gfc_build_class_symbol (ts, &attr, &as))
866 : 0 : gcc_unreachable ();
867 : :
868 : 109 : gfc_set_sym_referenced (ts->u.derived);
869 : :
870 : : /* Make sure the _vptr is set. */
871 : 109 : c = gfc_find_component (ts->u.derived, "_vptr", true, true, NULL);
872 : 109 : if (c->ts.u.derived == NULL)
873 : 48 : c->ts.u.derived = gfc_find_derived_vtab (der);
874 : : /* _vptr now has the _vtab in it, change it to the _vtype. */
875 : 109 : if (c->ts.u.derived->attr.vtab)
876 : 48 : c->ts.u.derived = c->ts.u.derived->ts.u.derived;
877 : 109 : }
878 : :
879 : :
880 : : /* Add a procedure pointer component to the vtype
881 : : to represent a specific type-bound procedure. */
882 : :
883 : : static void
884 : 4565 : add_proc_comp (gfc_symbol *vtype, const char *name, gfc_typebound_proc *tb)
885 : : {
886 : 4565 : gfc_component *c;
887 : 4565 : bool is_abstract = false;
888 : :
889 : 4565 : c = gfc_find_component (vtype, name, true, true, NULL);
890 : :
891 : : /* If the present component typebound proc is abstract, the new version
892 : : should unconditionally be tested if it is a suitable replacement. */
893 : 4565 : if (c && c->tb && c->tb->u.specific
894 : 1305 : && c->tb->u.specific->n.sym->attr.abstract)
895 : 4565 : is_abstract = true;
896 : :
897 : : /* Pass on the new tb being not overridable if a component is found and
898 : : either there is not an overridden specific or the present component
899 : : tb is abstract. This ensures that possible, viable replacements are
900 : : loaded. */
901 : 4565 : if (tb->non_overridable && !tb->overridden && !is_abstract && c)
902 : 7 : return;
903 : :
904 : 4558 : if (c == NULL)
905 : : {
906 : : /* Add procedure component. */
907 : 3242 : if (!gfc_add_component (vtype, name, &c))
908 : : return;
909 : :
910 : 3242 : if (!c->tb)
911 : 3242 : c->tb = XCNEW (gfc_typebound_proc);
912 : 3242 : *c->tb = *tb;
913 : 3242 : c->tb->ppc = 1;
914 : 3242 : c->attr.procedure = 1;
915 : 3242 : c->attr.proc_pointer = 1;
916 : 3242 : c->attr.flavor = FL_PROCEDURE;
917 : 3242 : c->attr.access = ACCESS_PRIVATE;
918 : 3242 : c->attr.external = 1;
919 : 3242 : c->attr.untyped = 1;
920 : 3242 : c->attr.if_source = IFSRC_IFBODY;
921 : : }
922 : 1316 : else if (c->attr.proc_pointer && c->tb)
923 : : {
924 : 1316 : *c->tb = *tb;
925 : 1316 : c->tb->ppc = 1;
926 : : }
927 : :
928 : 4558 : if (tb->u.specific)
929 : : {
930 : 4540 : gfc_symbol *ifc = tb->u.specific->n.sym;
931 : 4540 : c->ts.interface = ifc;
932 : 4540 : if (!tb->deferred)
933 : 3815 : c->initializer = gfc_get_variable_expr (tb->u.specific);
934 : 4540 : c->attr.pure = ifc->attr.pure;
935 : : }
936 : : }
937 : :
938 : :
939 : : /* Add all specific type-bound procedures in the symtree 'st' to a vtype. */
940 : :
941 : : static void
942 : 4418 : add_procs_to_declared_vtab1 (gfc_symtree *st, gfc_symbol *vtype)
943 : : {
944 : 4418 : if (!st)
945 : : return;
946 : :
947 : 4418 : if (st->left)
948 : 1130 : add_procs_to_declared_vtab1 (st->left, vtype);
949 : :
950 : 4418 : if (st->right)
951 : 1068 : add_procs_to_declared_vtab1 (st->right, vtype);
952 : :
953 : 4418 : if (st->n.tb && !st->n.tb->error
954 : 4417 : && !st->n.tb->is_generic && st->n.tb->u.specific)
955 : 3773 : add_proc_comp (vtype, st->name, st->n.tb);
956 : : }
957 : :
958 : :
959 : : /* Copy procedure pointers components from the parent type. */
960 : :
961 : : static void
962 : 1421 : copy_vtab_proc_comps (gfc_symbol *declared, gfc_symbol *vtype)
963 : : {
964 : 1421 : gfc_component *cmp;
965 : 1421 : gfc_symbol *vtab;
966 : :
967 : 1421 : vtab = gfc_find_derived_vtab (declared);
968 : :
969 : 12196 : for (cmp = vtab->ts.u.derived->components; cmp; cmp = cmp->next)
970 : : {
971 : 10775 : if (gfc_find_component (vtype, cmp->name, true, true, NULL))
972 : 9983 : continue;
973 : :
974 : 792 : add_proc_comp (vtype, cmp->name, cmp->tb);
975 : : }
976 : 1421 : }
977 : :
978 : :
979 : : /* Returns true if any of its nonpointer nonallocatable components or
980 : : their nonpointer nonallocatable subcomponents has a finalization
981 : : subroutine. */
982 : :
983 : : static bool
984 : 9590 : has_finalizer_component (gfc_symbol *derived)
985 : : {
986 : 9590 : gfc_component *c;
987 : :
988 : 20482 : for (c = derived->components; c; c = c->next)
989 : 10916 : if (c->ts.type == BT_DERIVED && !c->attr.pointer && !c->attr.allocatable
990 : 1856 : && c->attr.flavor != FL_PROCEDURE)
991 : : {
992 : 1850 : if (c->ts.u.derived->f2k_derived
993 : 1754 : && c->ts.u.derived->f2k_derived->finalizers)
994 : : return true;
995 : :
996 : : /* Stop infinite recursion through this function by inhibiting
997 : : calls when the derived type and that of the component are
998 : : the same. */
999 : 1826 : if (!gfc_compare_derived_types (derived, c->ts.u.derived)
1000 : 1826 : && has_finalizer_component (c->ts.u.derived))
1001 : : return true;
1002 : : }
1003 : : return false;
1004 : : }
1005 : :
1006 : :
1007 : : static bool
1008 : 6269 : comp_is_finalizable (gfc_component *comp)
1009 : : {
1010 : 6269 : if (comp->attr.proc_pointer)
1011 : : return false;
1012 : 6191 : else if (comp->attr.allocatable && comp->ts.type != BT_CLASS)
1013 : : return true;
1014 : 953 : else if (comp->ts.type == BT_DERIVED && !comp->attr.pointer
1015 : 4150 : && (comp->ts.u.derived->attr.alloc_comp
1016 : 413 : || has_finalizer_component (comp->ts.u.derived)
1017 : 413 : || (comp->ts.u.derived->f2k_derived
1018 : 389 : && comp->ts.u.derived->f2k_derived->finalizers)))
1019 : 579 : return true;
1020 : 2668 : else if (comp->ts.type == BT_CLASS && CLASS_DATA (comp)
1021 : 626 : && CLASS_DATA (comp)->attr.allocatable)
1022 : : return true;
1023 : : else
1024 : : return false;
1025 : : }
1026 : :
1027 : :
1028 : : /* Call DEALLOCATE for the passed component if it is allocatable, if it is
1029 : : neither allocatable nor a pointer but has a finalizer, call it. If it
1030 : : is a nonpointer component with allocatable components or has finalizers, walk
1031 : : them. Either of them is required; other nonallocatables and pointers aren't
1032 : : handled gracefully.
1033 : : Note: If the component is allocatable, the DEALLOCATE handling takes care
1034 : : of calling the appropriate finalizers, coarray deregistering, and
1035 : : deallocation of allocatable subcomponents. */
1036 : :
1037 : : static void
1038 : 3179 : finalize_component (gfc_expr *expr, gfc_symbol *derived, gfc_component *comp,
1039 : : gfc_symbol *stat, gfc_symbol *fini_coarray, gfc_code **code,
1040 : : gfc_namespace *sub_ns)
1041 : : {
1042 : 3179 : gfc_expr *e;
1043 : 3179 : gfc_ref *ref;
1044 : 3179 : gfc_was_finalized *f;
1045 : :
1046 : 3179 : if (!comp_is_finalizable (comp))
1047 : : return;
1048 : :
1049 : : /* If this expression with this component has been finalized
1050 : : already in this namespace, there is nothing to do. */
1051 : 2815 : for (f = sub_ns->was_finalized; f; f = f->next)
1052 : : {
1053 : 610 : if (f->e == expr && f->c == comp)
1054 : : return;
1055 : : }
1056 : :
1057 : 2205 : e = gfc_copy_expr (expr);
1058 : 2205 : if (!e->ref)
1059 : 1916 : e->ref = ref = gfc_get_ref ();
1060 : : else
1061 : : {
1062 : 374 : for (ref = e->ref; ref->next; ref = ref->next)
1063 : : ;
1064 : 289 : ref->next = gfc_get_ref ();
1065 : 289 : ref = ref->next;
1066 : : }
1067 : 2205 : ref->type = REF_COMPONENT;
1068 : 2205 : ref->u.c.sym = derived;
1069 : 2205 : ref->u.c.component = comp;
1070 : 2205 : e->ts = comp->ts;
1071 : :
1072 : 2205 : if (comp->attr.dimension || comp->attr.codimension
1073 : 1061 : || (comp->ts.type == BT_CLASS && CLASS_DATA (comp)
1074 : 326 : && (CLASS_DATA (comp)->attr.dimension
1075 : 326 : || CLASS_DATA (comp)->attr.codimension)))
1076 : : {
1077 : 1263 : ref->next = gfc_get_ref ();
1078 : 1263 : ref->next->type = REF_ARRAY;
1079 : 1263 : ref->next->u.ar.dimen = 0;
1080 : 1263 : ref->next->u.ar.as = comp->ts.type == BT_CLASS ? CLASS_DATA (comp)->as
1081 : : : comp->as;
1082 : 1263 : e->rank = ref->next->u.ar.as->rank;
1083 : 1263 : e->corank = ref->next->u.ar.as->corank;
1084 : 1280 : ref->next->u.ar.type = e->rank ? AR_FULL : AR_ELEMENT;
1085 : : }
1086 : :
1087 : : /* Call DEALLOCATE (comp, stat=ignore). */
1088 : 2205 : if (comp->attr.allocatable
1089 : 632 : || (comp->ts.type == BT_CLASS && CLASS_DATA (comp)
1090 : 326 : && CLASS_DATA (comp)->attr.allocatable))
1091 : : {
1092 : 1899 : gfc_code *dealloc, *block = NULL;
1093 : :
1094 : : /* Add IF (fini_coarray). */
1095 : 1899 : if (comp->attr.codimension
1096 : 1885 : || (comp->ts.type == BT_CLASS && CLASS_DATA (comp)
1097 : 326 : && CLASS_DATA (comp)->attr.codimension))
1098 : : {
1099 : 28 : block = gfc_get_code (EXEC_IF);
1100 : 28 : if (*code)
1101 : : {
1102 : 28 : (*code)->next = block;
1103 : 28 : (*code) = (*code)->next;
1104 : : }
1105 : : else
1106 : 0 : (*code) = block;
1107 : :
1108 : 28 : block->block = gfc_get_code (EXEC_IF);
1109 : 28 : block = block->block;
1110 : 28 : block->expr1 = gfc_lval_expr_from_sym (fini_coarray);
1111 : : }
1112 : :
1113 : 1899 : dealloc = gfc_get_code (EXEC_DEALLOCATE);
1114 : :
1115 : 1899 : dealloc->ext.alloc.list = gfc_get_alloc ();
1116 : 1899 : dealloc->ext.alloc.list->expr = e;
1117 : 1899 : dealloc->expr1 = gfc_lval_expr_from_sym (stat);
1118 : :
1119 : 1899 : gfc_code *cond = gfc_get_code (EXEC_IF);
1120 : 1899 : cond->block = gfc_get_code (EXEC_IF);
1121 : 1899 : cond->block->expr1 = gfc_get_expr ();
1122 : 1899 : cond->block->expr1->expr_type = EXPR_FUNCTION;
1123 : 1899 : cond->block->expr1->where = gfc_current_locus;
1124 : 1899 : gfc_get_sym_tree ("associated", sub_ns, &cond->block->expr1->symtree, false);
1125 : 1899 : cond->block->expr1->symtree->n.sym->attr.flavor = FL_PROCEDURE;
1126 : 1899 : cond->block->expr1->symtree->n.sym->attr.intrinsic = 1;
1127 : 1899 : cond->block->expr1->symtree->n.sym->result = cond->block->expr1->symtree->n.sym;
1128 : 1899 : gfc_commit_symbol (cond->block->expr1->symtree->n.sym);
1129 : 1899 : cond->block->expr1->ts.type = BT_LOGICAL;
1130 : 1899 : cond->block->expr1->ts.kind = gfc_default_logical_kind;
1131 : 1899 : cond->block->expr1->value.function.isym = gfc_intrinsic_function_by_id (GFC_ISYM_ASSOCIATED);
1132 : 1899 : cond->block->expr1->value.function.actual = gfc_get_actual_arglist ();
1133 : 1899 : cond->block->expr1->value.function.actual->expr = gfc_copy_expr (expr);
1134 : 1899 : cond->block->expr1->value.function.actual->next = gfc_get_actual_arglist ();
1135 : 1899 : cond->block->next = dealloc;
1136 : :
1137 : 1899 : if (block)
1138 : 28 : block->next = cond;
1139 : 1871 : else if (*code)
1140 : : {
1141 : 1871 : (*code)->next = cond;
1142 : 1871 : (*code) = (*code)->next;
1143 : : }
1144 : : else
1145 : 0 : (*code) = cond;
1146 : :
1147 : : }
1148 : 306 : else if (comp->ts.type == BT_DERIVED
1149 : 306 : && comp->ts.u.derived->f2k_derived
1150 : 306 : && comp->ts.u.derived->f2k_derived->finalizers)
1151 : : {
1152 : : /* Call FINAL_WRAPPER (comp); */
1153 : 70 : gfc_code *final_wrap;
1154 : 70 : gfc_symbol *vtab, *byte_stride;
1155 : 70 : gfc_expr *scalar, *size_expr, *fini_coarray_expr;
1156 : 70 : gfc_component *c;
1157 : :
1158 : 70 : vtab = gfc_find_derived_vtab (comp->ts.u.derived);
1159 : 420 : for (c = vtab->ts.u.derived->components; c; c = c->next)
1160 : 420 : if (strcmp (c->name, "_final") == 0)
1161 : : break;
1162 : :
1163 : 70 : gcc_assert (c);
1164 : :
1165 : : /* Set scalar argument for storage_size. A leading underscore in
1166 : : the name prevents an unwanted finalization. */
1167 : 70 : gfc_get_symbol ("_comp_byte_stride", sub_ns, &byte_stride);
1168 : 70 : byte_stride->ts = e->ts;
1169 : 70 : byte_stride->attr.flavor = FL_VARIABLE;
1170 : 70 : byte_stride->attr.value = 1;
1171 : 70 : byte_stride->attr.artificial = 1;
1172 : 70 : gfc_set_sym_referenced (byte_stride);
1173 : 70 : gfc_commit_symbol (byte_stride);
1174 : 70 : scalar = gfc_lval_expr_from_sym (byte_stride);
1175 : :
1176 : 70 : final_wrap = gfc_get_code (EXEC_CALL);
1177 : 70 : final_wrap->symtree = c->initializer->symtree;
1178 : 70 : final_wrap->resolved_sym = c->initializer->symtree->n.sym;
1179 : 70 : final_wrap->ext.actual = gfc_get_actual_arglist ();
1180 : 70 : final_wrap->ext.actual->expr = e;
1181 : :
1182 : : /* size_expr = STORAGE_SIZE (...) / NUMERIC_STORAGE_SIZE. */
1183 : 70 : size_expr = gfc_get_expr ();
1184 : 70 : size_expr->where = gfc_current_locus;
1185 : 70 : size_expr->expr_type = EXPR_OP;
1186 : 70 : size_expr->value.op.op = INTRINSIC_DIVIDE;
1187 : :
1188 : : /* STORAGE_SIZE (array,kind=c_intptr_t). */
1189 : 70 : size_expr->value.op.op1
1190 : 70 : = gfc_build_intrinsic_call (sub_ns, GFC_ISYM_STORAGE_SIZE,
1191 : : "storage_size", gfc_current_locus, 2,
1192 : : scalar,
1193 : : gfc_get_int_expr (gfc_index_integer_kind,
1194 : : NULL, 0));
1195 : :
1196 : : /* NUMERIC_STORAGE_SIZE. */
1197 : 70 : size_expr->value.op.op2 = gfc_get_int_expr (gfc_index_integer_kind, NULL,
1198 : : gfc_character_storage_size);
1199 : 70 : size_expr->value.op.op1->ts = size_expr->value.op.op2->ts;
1200 : 70 : size_expr->ts = size_expr->value.op.op1->ts;
1201 : :
1202 : : /* Which provides the argument 'byte_stride'..... */
1203 : 70 : final_wrap->ext.actual->next = gfc_get_actual_arglist ();
1204 : 70 : final_wrap->ext.actual->next->expr = size_expr;
1205 : :
1206 : : /* ...and last of all the 'fini_coarray' argument. */
1207 : 70 : fini_coarray_expr = gfc_lval_expr_from_sym (fini_coarray);
1208 : 70 : final_wrap->ext.actual->next->next = gfc_get_actual_arglist ();
1209 : 70 : final_wrap->ext.actual->next->next->expr = fini_coarray_expr;
1210 : :
1211 : :
1212 : :
1213 : 70 : if (*code)
1214 : : {
1215 : 70 : (*code)->next = final_wrap;
1216 : 70 : (*code) = (*code)->next;
1217 : : }
1218 : : else
1219 : 0 : (*code) = final_wrap;
1220 : 70 : }
1221 : : else
1222 : : {
1223 : 236 : gfc_component *c;
1224 : :
1225 : 656 : for (c = comp->ts.u.derived->components; c; c = c->next)
1226 : 420 : finalize_component (e, comp->ts.u.derived, c, stat, fini_coarray, code,
1227 : : sub_ns);
1228 : 236 : gfc_free_expr (e);
1229 : : }
1230 : :
1231 : : /* Record that this was finalized already in this namespace. */
1232 : 2205 : f = sub_ns->was_finalized;
1233 : 2205 : sub_ns->was_finalized = XCNEW (gfc_was_finalized);
1234 : 2205 : sub_ns->was_finalized->e = expr;
1235 : 2205 : sub_ns->was_finalized->c = comp;
1236 : 2205 : sub_ns->was_finalized->next = f;
1237 : : }
1238 : :
1239 : :
1240 : : /* Generate code equivalent to
1241 : : CALL C_F_POINTER (TRANSFER (TRANSFER (C_LOC (array, cptr), c_intptr)
1242 : : + offset, c_ptr), ptr). */
1243 : :
1244 : : static gfc_code *
1245 : 2128 : finalization_scalarizer (gfc_symbol *array, gfc_symbol *ptr,
1246 : : gfc_expr *offset, gfc_namespace *sub_ns)
1247 : : {
1248 : 2128 : gfc_code *block;
1249 : 2128 : gfc_expr *expr, *expr2;
1250 : :
1251 : : /* C_F_POINTER(). */
1252 : 2128 : block = gfc_get_code (EXEC_CALL);
1253 : 2128 : gfc_get_sym_tree ("c_f_pointer", sub_ns, &block->symtree, true);
1254 : 2128 : block->resolved_sym = block->symtree->n.sym;
1255 : 2128 : block->resolved_sym->attr.flavor = FL_PROCEDURE;
1256 : 2128 : block->resolved_sym->attr.intrinsic = 1;
1257 : 2128 : block->resolved_sym->attr.subroutine = 1;
1258 : 2128 : block->resolved_sym->from_intmod = INTMOD_ISO_C_BINDING;
1259 : 2128 : block->resolved_sym->intmod_sym_id = ISOCBINDING_F_POINTER;
1260 : 2128 : block->resolved_isym = gfc_intrinsic_subroutine_by_id (GFC_ISYM_C_F_POINTER);
1261 : 2128 : gfc_commit_symbol (block->resolved_sym);
1262 : :
1263 : : /* C_F_POINTER's first argument: TRANSFER ( <addr>, c_intptr_t). */
1264 : 2128 : block->ext.actual = gfc_get_actual_arglist ();
1265 : 2128 : block->ext.actual->next = gfc_get_actual_arglist ();
1266 : 2128 : block->ext.actual->next->expr = gfc_get_int_expr (gfc_index_integer_kind,
1267 : : NULL, 0);
1268 : 2128 : block->ext.actual->next->next = gfc_get_actual_arglist (); /* SIZE. */
1269 : :
1270 : : /* The <addr> part: TRANSFER (C_LOC (array), c_intptr_t). */
1271 : :
1272 : : /* TRANSFER's first argument: C_LOC (array). */
1273 : 2128 : expr = gfc_get_expr ();
1274 : 2128 : expr->expr_type = EXPR_FUNCTION;
1275 : 2128 : gfc_get_sym_tree ("c_loc", sub_ns, &expr->symtree, false);
1276 : 2128 : expr->symtree->n.sym->attr.flavor = FL_PROCEDURE;
1277 : 2128 : expr->symtree->n.sym->intmod_sym_id = ISOCBINDING_LOC;
1278 : 2128 : expr->symtree->n.sym->attr.intrinsic = 1;
1279 : 2128 : expr->symtree->n.sym->from_intmod = INTMOD_ISO_C_BINDING;
1280 : 2128 : expr->value.function.isym = gfc_intrinsic_function_by_id (GFC_ISYM_C_LOC);
1281 : 2128 : expr->value.function.actual = gfc_get_actual_arglist ();
1282 : 2128 : expr->value.function.actual->expr
1283 : 2128 : = gfc_lval_expr_from_sym (array);
1284 : 2128 : expr->symtree->n.sym->result = expr->symtree->n.sym;
1285 : 2128 : gfc_commit_symbol (expr->symtree->n.sym);
1286 : 2128 : expr->ts.type = BT_INTEGER;
1287 : 2128 : expr->ts.kind = gfc_index_integer_kind;
1288 : 2128 : expr->where = gfc_current_locus;
1289 : :
1290 : : /* TRANSFER. */
1291 : 2128 : expr2 = gfc_build_intrinsic_call (sub_ns, GFC_ISYM_TRANSFER, "transfer",
1292 : : gfc_current_locus, 3, expr,
1293 : : gfc_get_int_expr (gfc_index_integer_kind,
1294 : : NULL, 0), NULL);
1295 : 2128 : expr2->ts.type = BT_INTEGER;
1296 : 2128 : expr2->ts.kind = gfc_index_integer_kind;
1297 : :
1298 : : /* <array addr> + <offset>. */
1299 : 2128 : block->ext.actual->expr = gfc_get_expr ();
1300 : 2128 : block->ext.actual->expr->expr_type = EXPR_OP;
1301 : 2128 : block->ext.actual->expr->value.op.op = INTRINSIC_PLUS;
1302 : 2128 : block->ext.actual->expr->value.op.op1 = expr2;
1303 : 2128 : block->ext.actual->expr->value.op.op2 = offset;
1304 : 2128 : block->ext.actual->expr->ts = expr->ts;
1305 : 2128 : block->ext.actual->expr->where = gfc_current_locus;
1306 : :
1307 : : /* C_F_POINTER's 2nd arg: ptr -- and its absent shape=. */
1308 : 2128 : block->ext.actual->next = gfc_get_actual_arglist ();
1309 : 2128 : block->ext.actual->next->expr = gfc_lval_expr_from_sym (ptr);
1310 : 2128 : block->ext.actual->next->next = gfc_get_actual_arglist ();
1311 : :
1312 : 2128 : return block;
1313 : : }
1314 : :
1315 : :
1316 : : /* Calculates the offset to the (idx+1)th element of an array, taking the
1317 : : stride into account. It generates the code:
1318 : : offset = 0
1319 : : do idx2 = 1, rank
1320 : : offset = offset + mod (idx, sizes(idx2)) / sizes(idx2-1) * strides(idx2)
1321 : : end do
1322 : : offset = offset * byte_stride. */
1323 : :
1324 : : static gfc_code*
1325 : 1918 : finalization_get_offset (gfc_symbol *idx, gfc_symbol *idx2, gfc_symbol *offset,
1326 : : gfc_symbol *strides, gfc_symbol *sizes,
1327 : : gfc_symbol *byte_stride, gfc_expr *rank,
1328 : : gfc_code *block, gfc_namespace *sub_ns)
1329 : : {
1330 : 1918 : gfc_iterator *iter;
1331 : 1918 : gfc_expr *expr, *expr2;
1332 : :
1333 : : /* offset = 0. */
1334 : 1918 : block->next = gfc_get_code (EXEC_ASSIGN);
1335 : 1918 : block = block->next;
1336 : 1918 : block->expr1 = gfc_lval_expr_from_sym (offset);
1337 : 1918 : block->expr2 = gfc_get_int_expr (gfc_index_integer_kind, NULL, 0);
1338 : :
1339 : : /* Create loop. */
1340 : 1918 : iter = gfc_get_iterator ();
1341 : 1918 : iter->var = gfc_lval_expr_from_sym (idx2);
1342 : 1918 : iter->start = gfc_get_int_expr (gfc_index_integer_kind, NULL, 1);
1343 : 1918 : iter->end = gfc_copy_expr (rank);
1344 : 1918 : iter->step = gfc_get_int_expr (gfc_index_integer_kind, NULL, 1);
1345 : 1918 : block->next = gfc_get_code (EXEC_DO);
1346 : 1918 : block = block->next;
1347 : 1918 : block->ext.iterator = iter;
1348 : 1918 : block->block = gfc_get_code (EXEC_DO);
1349 : :
1350 : : /* Loop body: offset = offset + mod (idx, sizes(idx2)) / sizes(idx2-1)
1351 : : * strides(idx2). */
1352 : :
1353 : : /* mod (idx, sizes(idx2)). */
1354 : 1918 : expr = gfc_lval_expr_from_sym (sizes);
1355 : 1918 : expr->ref = gfc_get_ref ();
1356 : 1918 : expr->ref->type = REF_ARRAY;
1357 : 1918 : expr->ref->u.ar.as = sizes->as;
1358 : 1918 : expr->ref->u.ar.type = AR_ELEMENT;
1359 : 1918 : expr->ref->u.ar.dimen = 1;
1360 : 1918 : expr->ref->u.ar.dimen_type[0] = DIMEN_ELEMENT;
1361 : 1918 : expr->ref->u.ar.start[0] = gfc_lval_expr_from_sym (idx2);
1362 : 1918 : expr->where = sizes->declared_at;
1363 : :
1364 : 1918 : expr = gfc_build_intrinsic_call (sub_ns, GFC_ISYM_MOD, "mod",
1365 : : gfc_current_locus, 2,
1366 : : gfc_lval_expr_from_sym (idx), expr);
1367 : 1918 : expr->ts = idx->ts;
1368 : :
1369 : : /* (...) / sizes(idx2-1). */
1370 : 1918 : expr2 = gfc_get_expr ();
1371 : 1918 : expr2->expr_type = EXPR_OP;
1372 : 1918 : expr2->value.op.op = INTRINSIC_DIVIDE;
1373 : 1918 : expr2->value.op.op1 = expr;
1374 : 1918 : expr2->value.op.op2 = gfc_lval_expr_from_sym (sizes);
1375 : 1918 : expr2->value.op.op2->ref = gfc_get_ref ();
1376 : 1918 : expr2->value.op.op2->ref->type = REF_ARRAY;
1377 : 1918 : expr2->value.op.op2->ref->u.ar.as = sizes->as;
1378 : 1918 : expr2->value.op.op2->ref->u.ar.type = AR_ELEMENT;
1379 : 1918 : expr2->value.op.op2->ref->u.ar.dimen = 1;
1380 : 1918 : expr2->value.op.op2->ref->u.ar.dimen_type[0] = DIMEN_ELEMENT;
1381 : 1918 : expr2->value.op.op2->ref->u.ar.start[0] = gfc_get_expr ();
1382 : 1918 : expr2->value.op.op2->ref->u.ar.start[0]->expr_type = EXPR_OP;
1383 : 1918 : expr2->value.op.op2->ref->u.ar.start[0]->where = gfc_current_locus;
1384 : 1918 : expr2->value.op.op2->ref->u.ar.start[0]->value.op.op = INTRINSIC_MINUS;
1385 : 1918 : expr2->value.op.op2->ref->u.ar.start[0]->value.op.op1
1386 : 1918 : = gfc_lval_expr_from_sym (idx2);
1387 : 1918 : expr2->value.op.op2->ref->u.ar.start[0]->value.op.op2
1388 : 1918 : = gfc_get_int_expr (gfc_index_integer_kind, NULL, 1);
1389 : 1918 : expr2->value.op.op2->ref->u.ar.start[0]->ts
1390 : 1918 : = expr2->value.op.op2->ref->u.ar.start[0]->value.op.op1->ts;
1391 : 1918 : expr2->ts = idx->ts;
1392 : 1918 : expr2->where = gfc_current_locus;
1393 : :
1394 : : /* ... * strides(idx2). */
1395 : 1918 : expr = gfc_get_expr ();
1396 : 1918 : expr->expr_type = EXPR_OP;
1397 : 1918 : expr->value.op.op = INTRINSIC_TIMES;
1398 : 1918 : expr->value.op.op1 = expr2;
1399 : 1918 : expr->value.op.op2 = gfc_lval_expr_from_sym (strides);
1400 : 1918 : expr->value.op.op2->ref = gfc_get_ref ();
1401 : 1918 : expr->value.op.op2->ref->type = REF_ARRAY;
1402 : 1918 : expr->value.op.op2->ref->u.ar.type = AR_ELEMENT;
1403 : 1918 : expr->value.op.op2->ref->u.ar.dimen = 1;
1404 : 1918 : expr->value.op.op2->ref->u.ar.dimen_type[0] = DIMEN_ELEMENT;
1405 : 1918 : expr->value.op.op2->ref->u.ar.start[0] = gfc_lval_expr_from_sym (idx2);
1406 : 1918 : expr->value.op.op2->ref->u.ar.as = strides->as;
1407 : 1918 : expr->ts = idx->ts;
1408 : 1918 : expr->where = gfc_current_locus;
1409 : :
1410 : : /* offset = offset + ... */
1411 : 1918 : block->block->next = gfc_get_code (EXEC_ASSIGN);
1412 : 1918 : block->block->next->expr1 = gfc_lval_expr_from_sym (offset);
1413 : 1918 : block->block->next->expr2 = gfc_get_expr ();
1414 : 1918 : block->block->next->expr2->expr_type = EXPR_OP;
1415 : 1918 : block->block->next->expr2->value.op.op = INTRINSIC_PLUS;
1416 : 1918 : block->block->next->expr2->value.op.op1 = gfc_lval_expr_from_sym (offset);
1417 : 1918 : block->block->next->expr2->value.op.op2 = expr;
1418 : 1918 : block->block->next->expr2->ts = idx->ts;
1419 : 1918 : block->block->next->expr2->where = gfc_current_locus;
1420 : :
1421 : : /* After the loop: offset = offset * byte_stride. */
1422 : 1918 : block->next = gfc_get_code (EXEC_ASSIGN);
1423 : 1918 : block = block->next;
1424 : 1918 : block->expr1 = gfc_lval_expr_from_sym (offset);
1425 : 1918 : block->expr2 = gfc_get_expr ();
1426 : 1918 : block->expr2->expr_type = EXPR_OP;
1427 : 1918 : block->expr2->value.op.op = INTRINSIC_TIMES;
1428 : 1918 : block->expr2->value.op.op1 = gfc_lval_expr_from_sym (offset);
1429 : 1918 : block->expr2->value.op.op2 = gfc_lval_expr_from_sym (byte_stride);
1430 : 1918 : block->expr2->ts = block->expr2->value.op.op1->ts;
1431 : 1918 : block->expr2->where = gfc_current_locus;
1432 : 1918 : return block;
1433 : : }
1434 : :
1435 : :
1436 : : /* Insert code of the following form:
1437 : :
1438 : : block
1439 : : integer(c_intptr_t) :: i
1440 : :
1441 : : if ((byte_stride == STORAGE_SIZE (array)/NUMERIC_STORAGE_SIZE
1442 : : && (is_contiguous || !final_rank3->attr.contiguous
1443 : : || final_rank3->as->type != AS_ASSUMED_SHAPE))
1444 : : || 0 == STORAGE_SIZE (array)) then
1445 : : call final_rank3 (array)
1446 : : else
1447 : : block
1448 : : integer(c_intptr_t) :: offset, j
1449 : : type(t) :: tmp(shape (array))
1450 : :
1451 : : do i = 0, size (array)-1
1452 : : offset = obtain_offset(i, strides, sizes, byte_stride)
1453 : : addr = transfer (c_loc (array), addr) + offset
1454 : : call c_f_pointer (transfer (addr, cptr), ptr)
1455 : :
1456 : : addr = transfer (c_loc (tmp), addr)
1457 : : + i * STORAGE_SIZE (array)/NUMERIC_STORAGE_SIZE
1458 : : call c_f_pointer (transfer (addr, cptr), ptr2)
1459 : : ptr2 = ptr
1460 : : end do
1461 : : call final_rank3 (tmp)
1462 : : end block
1463 : : end if
1464 : : block */
1465 : :
1466 : : static void
1467 : 114 : finalizer_insert_packed_call (gfc_code *block, gfc_finalizer *fini,
1468 : : gfc_symbol *array, gfc_symbol *byte_stride,
1469 : : gfc_symbol *idx, gfc_symbol *ptr,
1470 : : gfc_symbol *nelem,
1471 : : gfc_symbol *strides, gfc_symbol *sizes,
1472 : : gfc_symbol *idx2, gfc_symbol *offset,
1473 : : gfc_symbol *is_contiguous, gfc_expr *rank,
1474 : : gfc_namespace *sub_ns)
1475 : : {
1476 : 114 : gfc_symbol *tmp_array, *ptr2;
1477 : 114 : gfc_expr *size_expr, *offset2, *expr;
1478 : 114 : gfc_namespace *ns;
1479 : 114 : gfc_iterator *iter;
1480 : 114 : gfc_code *block2;
1481 : 114 : int i;
1482 : :
1483 : 114 : block->next = gfc_get_code (EXEC_IF);
1484 : 114 : block = block->next;
1485 : :
1486 : 114 : block->block = gfc_get_code (EXEC_IF);
1487 : 114 : block = block->block;
1488 : :
1489 : : /* size_expr = STORAGE_SIZE (...) / NUMERIC_STORAGE_SIZE. */
1490 : 114 : size_expr = gfc_get_expr ();
1491 : 114 : size_expr->where = gfc_current_locus;
1492 : 114 : size_expr->expr_type = EXPR_OP;
1493 : 114 : size_expr->value.op.op = INTRINSIC_DIVIDE;
1494 : :
1495 : : /* STORAGE_SIZE (array,kind=c_intptr_t). */
1496 : 114 : size_expr->value.op.op1
1497 : 114 : = gfc_build_intrinsic_call (sub_ns, GFC_ISYM_STORAGE_SIZE,
1498 : : "storage_size", gfc_current_locus, 2,
1499 : : gfc_lval_expr_from_sym (array),
1500 : : gfc_get_int_expr (gfc_index_integer_kind,
1501 : : NULL, 0));
1502 : :
1503 : : /* NUMERIC_STORAGE_SIZE. */
1504 : 114 : size_expr->value.op.op2 = gfc_get_int_expr (gfc_index_integer_kind, NULL,
1505 : : gfc_character_storage_size);
1506 : 114 : size_expr->value.op.op1->ts = size_expr->value.op.op2->ts;
1507 : 114 : size_expr->ts = size_expr->value.op.op1->ts;
1508 : :
1509 : : /* IF condition: (stride == size_expr
1510 : : && ((fini's as->ASSUMED_SIZE && !fini's attr.contiguous)
1511 : : || is_contiguous)
1512 : : || 0 == size_expr. */
1513 : 114 : block->expr1 = gfc_get_expr ();
1514 : 114 : block->expr1->ts.type = BT_LOGICAL;
1515 : 114 : block->expr1->ts.kind = gfc_default_logical_kind;
1516 : 114 : block->expr1->expr_type = EXPR_OP;
1517 : 114 : block->expr1->where = gfc_current_locus;
1518 : :
1519 : 114 : block->expr1->value.op.op = INTRINSIC_OR;
1520 : :
1521 : : /* byte_stride == size_expr */
1522 : 114 : expr = gfc_get_expr ();
1523 : 114 : expr->ts.type = BT_LOGICAL;
1524 : 114 : expr->ts.kind = gfc_default_logical_kind;
1525 : 114 : expr->expr_type = EXPR_OP;
1526 : 114 : expr->where = gfc_current_locus;
1527 : 114 : expr->value.op.op = INTRINSIC_EQ;
1528 : 114 : expr->value.op.op1
1529 : 114 : = gfc_lval_expr_from_sym (byte_stride);
1530 : 114 : expr->value.op.op2 = size_expr;
1531 : :
1532 : : /* If strides aren't allowed (not assumed shape or CONTIGUOUS),
1533 : : add is_contiguous check. */
1534 : :
1535 : 114 : if (fini->proc_tree->n.sym->formal->sym->as->type != AS_ASSUMED_SHAPE
1536 : 94 : || fini->proc_tree->n.sym->formal->sym->attr.contiguous)
1537 : : {
1538 : 26 : gfc_expr *expr2;
1539 : 26 : expr2 = gfc_get_expr ();
1540 : 26 : expr2->ts.type = BT_LOGICAL;
1541 : 26 : expr2->ts.kind = gfc_default_logical_kind;
1542 : 26 : expr2->expr_type = EXPR_OP;
1543 : 26 : expr2->where = gfc_current_locus;
1544 : 26 : expr2->value.op.op = INTRINSIC_AND;
1545 : 26 : expr2->value.op.op1 = expr;
1546 : 26 : expr2->value.op.op2 = gfc_lval_expr_from_sym (is_contiguous);
1547 : 26 : expr = expr2;
1548 : : }
1549 : :
1550 : 114 : block->expr1->value.op.op1 = expr;
1551 : :
1552 : : /* 0 == size_expr */
1553 : 114 : block->expr1->value.op.op2 = gfc_get_expr ();
1554 : 114 : block->expr1->value.op.op2->ts.type = BT_LOGICAL;
1555 : 114 : block->expr1->value.op.op2->ts.kind = gfc_default_logical_kind;
1556 : 114 : block->expr1->value.op.op2->expr_type = EXPR_OP;
1557 : 114 : block->expr1->value.op.op2->where = gfc_current_locus;
1558 : 114 : block->expr1->value.op.op2->value.op.op = INTRINSIC_EQ;
1559 : 228 : block->expr1->value.op.op2->value.op.op1 =
1560 : 114 : gfc_get_int_expr (gfc_index_integer_kind, NULL, 0);
1561 : 114 : block->expr1->value.op.op2->value.op.op2 = gfc_copy_expr (size_expr);
1562 : :
1563 : : /* IF body: call final subroutine. */
1564 : 114 : block->next = gfc_get_code (EXEC_CALL);
1565 : 114 : block->next->symtree = fini->proc_tree;
1566 : 114 : block->next->resolved_sym = fini->proc_tree->n.sym;
1567 : 114 : block->next->ext.actual = gfc_get_actual_arglist ();
1568 : 114 : block->next->ext.actual->expr = gfc_lval_expr_from_sym (array);
1569 : :
1570 : : /* ELSE. */
1571 : :
1572 : 114 : block->block = gfc_get_code (EXEC_IF);
1573 : 114 : block = block->block;
1574 : :
1575 : : /* BLOCK ... END BLOCK. */
1576 : 114 : block->next = gfc_get_code (EXEC_BLOCK);
1577 : 114 : block = block->next;
1578 : :
1579 : 114 : ns = gfc_build_block_ns (sub_ns);
1580 : 114 : block->ext.block.ns = ns;
1581 : 114 : block->ext.block.assoc = NULL;
1582 : :
1583 : 114 : gfc_get_symbol ("ptr2", ns, &ptr2);
1584 : 114 : ptr2->ts.type = BT_DERIVED;
1585 : 114 : ptr2->ts.u.derived = array->ts.u.derived;
1586 : 114 : ptr2->attr.flavor = FL_VARIABLE;
1587 : 114 : ptr2->attr.pointer = 1;
1588 : 114 : ptr2->attr.artificial = 1;
1589 : 114 : gfc_set_sym_referenced (ptr2);
1590 : 114 : gfc_commit_symbol (ptr2);
1591 : :
1592 : 114 : gfc_get_symbol ("tmp_array", ns, &tmp_array);
1593 : 114 : tmp_array->ts.type = BT_DERIVED;
1594 : 114 : tmp_array->ts.u.derived = array->ts.u.derived;
1595 : 114 : tmp_array->attr.flavor = FL_VARIABLE;
1596 : 114 : tmp_array->attr.dimension = 1;
1597 : 114 : tmp_array->attr.artificial = 1;
1598 : 114 : tmp_array->as = gfc_get_array_spec();
1599 : 114 : tmp_array->attr.intent = INTENT_INOUT;
1600 : 114 : tmp_array->as->type = AS_EXPLICIT;
1601 : 114 : tmp_array->as->rank = fini->proc_tree->n.sym->formal->sym->as->rank;
1602 : :
1603 : 302 : for (i = 0; i < tmp_array->as->rank; i++)
1604 : : {
1605 : 188 : gfc_expr *shape_expr;
1606 : 188 : tmp_array->as->lower[i] = gfc_get_int_expr (gfc_default_integer_kind,
1607 : : NULL, 1);
1608 : : /* SIZE (array, dim=i+1, kind=gfc_index_integer_kind). */
1609 : 188 : shape_expr
1610 : 376 : = gfc_build_intrinsic_call (sub_ns, GFC_ISYM_SIZE, "size",
1611 : : gfc_current_locus, 3,
1612 : : gfc_lval_expr_from_sym (array),
1613 : : gfc_get_int_expr (gfc_default_integer_kind,
1614 : 188 : NULL, i+1),
1615 : : gfc_get_int_expr (gfc_default_integer_kind,
1616 : : NULL,
1617 : : gfc_index_integer_kind));
1618 : 188 : shape_expr->ts.kind = gfc_index_integer_kind;
1619 : 188 : tmp_array->as->upper[i] = shape_expr;
1620 : : }
1621 : 114 : gfc_set_sym_referenced (tmp_array);
1622 : 114 : gfc_commit_symbol (tmp_array);
1623 : :
1624 : : /* Create loop. */
1625 : 114 : iter = gfc_get_iterator ();
1626 : 114 : iter->var = gfc_lval_expr_from_sym (idx);
1627 : 114 : iter->start = gfc_get_int_expr (gfc_index_integer_kind, NULL, 0);
1628 : 114 : iter->end = gfc_lval_expr_from_sym (nelem);
1629 : 114 : iter->step = gfc_get_int_expr (gfc_index_integer_kind, NULL, 1);
1630 : :
1631 : 114 : block = gfc_get_code (EXEC_DO);
1632 : 114 : ns->code = block;
1633 : 114 : block->ext.iterator = iter;
1634 : 114 : block->block = gfc_get_code (EXEC_DO);
1635 : :
1636 : : /* Offset calculation for the new array: idx * size of type (in bytes). */
1637 : 114 : offset2 = gfc_get_expr ();
1638 : 114 : offset2->expr_type = EXPR_OP;
1639 : 114 : offset2->where = gfc_current_locus;
1640 : 114 : offset2->value.op.op = INTRINSIC_TIMES;
1641 : 114 : offset2->value.op.op1 = gfc_lval_expr_from_sym (idx);
1642 : 114 : offset2->value.op.op2 = gfc_copy_expr (size_expr);
1643 : 114 : offset2->ts = byte_stride->ts;
1644 : :
1645 : : /* Offset calculation of "array". */
1646 : 114 : block2 = finalization_get_offset (idx, idx2, offset, strides, sizes,
1647 : : byte_stride, rank, block->block, sub_ns);
1648 : :
1649 : : /* Create code for
1650 : : CALL C_F_POINTER (TRANSFER (TRANSFER (C_LOC (array, cptr), c_intptr)
1651 : : + idx * stride, c_ptr), ptr). */
1652 : 114 : block2->next = finalization_scalarizer (array, ptr,
1653 : : gfc_lval_expr_from_sym (offset),
1654 : : sub_ns);
1655 : 114 : block2 = block2->next;
1656 : 114 : block2->next = finalization_scalarizer (tmp_array, ptr2, offset2, sub_ns);
1657 : 114 : block2 = block2->next;
1658 : :
1659 : : /* ptr2 = ptr. */
1660 : 114 : block2->next = gfc_get_code (EXEC_ASSIGN);
1661 : 114 : block2 = block2->next;
1662 : 114 : block2->expr1 = gfc_lval_expr_from_sym (ptr2);
1663 : 114 : block2->expr2 = gfc_lval_expr_from_sym (ptr);
1664 : :
1665 : : /* Call now the user's final subroutine. */
1666 : 114 : block->next = gfc_get_code (EXEC_CALL);
1667 : 114 : block = block->next;
1668 : 114 : block->symtree = fini->proc_tree;
1669 : 114 : block->resolved_sym = fini->proc_tree->n.sym;
1670 : 114 : block->ext.actual = gfc_get_actual_arglist ();
1671 : 114 : block->ext.actual->expr = gfc_lval_expr_from_sym (tmp_array);
1672 : :
1673 : 114 : if (fini->proc_tree->n.sym->formal->sym->attr.intent == INTENT_IN)
1674 : 18 : return;
1675 : :
1676 : : /* Copy back. */
1677 : :
1678 : : /* Loop. */
1679 : 96 : iter = gfc_get_iterator ();
1680 : 96 : iter->var = gfc_lval_expr_from_sym (idx);
1681 : 96 : iter->start = gfc_get_int_expr (gfc_index_integer_kind, NULL, 0);
1682 : 96 : iter->end = gfc_lval_expr_from_sym (nelem);
1683 : 96 : iter->step = gfc_get_int_expr (gfc_index_integer_kind, NULL, 1);
1684 : :
1685 : 96 : block->next = gfc_get_code (EXEC_DO);
1686 : 96 : block = block->next;
1687 : 96 : block->ext.iterator = iter;
1688 : 96 : block->block = gfc_get_code (EXEC_DO);
1689 : :
1690 : : /* Offset calculation of "array". */
1691 : 96 : block2 = finalization_get_offset (idx, idx2, offset, strides, sizes,
1692 : : byte_stride, rank, block->block, sub_ns);
1693 : :
1694 : : /* Create code for
1695 : : CALL C_F_POINTER (TRANSFER (TRANSFER (C_LOC (array, cptr), c_intptr)
1696 : : + offset, c_ptr), ptr). */
1697 : 96 : block2->next = finalization_scalarizer (array, ptr,
1698 : : gfc_lval_expr_from_sym (offset),
1699 : : sub_ns);
1700 : 96 : block2 = block2->next;
1701 : 96 : block2->next = finalization_scalarizer (tmp_array, ptr2,
1702 : : gfc_copy_expr (offset2), sub_ns);
1703 : 96 : block2 = block2->next;
1704 : :
1705 : : /* ptr = ptr2. */
1706 : 96 : block2->next = gfc_get_code (EXEC_ASSIGN);
1707 : 96 : block2->next->expr1 = gfc_lval_expr_from_sym (ptr);
1708 : 96 : block2->next->expr2 = gfc_lval_expr_from_sym (ptr2);
1709 : : }
1710 : :
1711 : :
1712 : : /* Generate the finalization/polymorphic freeing wrapper subroutine for the
1713 : : derived type "derived". The function first calls the appropriate FINAL
1714 : : subroutine, then it DEALLOCATEs (finalizes/frees) the allocatable
1715 : : components (but not the inherited ones). Last, it calls the wrapper
1716 : : subroutine of the parent. The generated wrapper procedure takes as argument
1717 : : an assumed-rank array.
1718 : : If neither allocatable components nor FINAL subroutines exists, the vtab
1719 : : will contain a NULL pointer.
1720 : : The generated function has the form
1721 : : _final(assumed-rank array, stride, skip_corarray)
1722 : : where the array has to be contiguous (except of the lowest dimension). The
1723 : : stride (in bytes) is used to allow different sizes for ancestor types by
1724 : : skipping over the additionally added components in the scalarizer. If
1725 : : "fini_coarray" is false, coarray components are not finalized to allow for
1726 : : the correct semantic with intrinsic assignment. */
1727 : :
1728 : : static void
1729 : 9709 : generate_finalization_wrapper (gfc_symbol *derived, gfc_namespace *ns,
1730 : : const char *tname, gfc_component *vtab_final)
1731 : : {
1732 : 9709 : gfc_symbol *final, *array, *fini_coarray, *byte_stride, *sizes, *strides;
1733 : 9709 : gfc_symbol *ptr = NULL, *idx, *idx2, *is_contiguous, *offset, *nelem;
1734 : 9709 : gfc_component *comp;
1735 : 9709 : gfc_namespace *sub_ns;
1736 : 9709 : gfc_code *last_code, *block;
1737 : 9709 : char *name;
1738 : 9709 : bool finalizable_comp = false;
1739 : 9709 : gfc_expr *ancestor_wrapper = NULL, *rank;
1740 : 9709 : gfc_iterator *iter;
1741 : :
1742 : 9709 : if (derived->attr.unlimited_polymorphic || derived->error)
1743 : : {
1744 : 708 : vtab_final->initializer = gfc_get_null_expr (NULL);
1745 : 7789 : return;
1746 : : }
1747 : :
1748 : : /* Search for the ancestor's finalizers. */
1749 : 1302 : if (derived->attr.extension && derived->components
1750 : 10303 : && (!derived->components->ts.u.derived->attr.abstract
1751 : 303 : || has_finalizer_component (derived)))
1752 : : {
1753 : 999 : gfc_symbol *vtab;
1754 : 999 : gfc_component *comp;
1755 : :
1756 : 999 : vtab = gfc_find_derived_vtab (derived->components->ts.u.derived);
1757 : 5994 : for (comp = vtab->ts.u.derived->components; comp; comp = comp->next)
1758 : 5994 : if (comp->name[0] == '_' && comp->name[1] == 'f')
1759 : : {
1760 : 999 : ancestor_wrapper = comp->initializer;
1761 : 999 : break;
1762 : : }
1763 : : }
1764 : :
1765 : : /* No wrapper of the ancestor and no own FINAL subroutines and allocatable
1766 : : components: Return a NULL() expression; we defer this a bit to have
1767 : : an interface declaration. */
1768 : 999 : if ((!ancestor_wrapper || ancestor_wrapper->expr_type == EXPR_NULL)
1769 : 8829 : && !derived->attr.alloc_comp
1770 : 7314 : && (!derived->f2k_derived || !derived->f2k_derived->finalizers)
1771 : 8047 : && !has_finalizer_component (derived))
1772 : : {
1773 : 7024 : vtab_final->initializer = gfc_get_null_expr (NULL);
1774 : 7024 : gcc_assert (vtab_final->ts.interface == NULL);
1775 : : return;
1776 : : }
1777 : : else
1778 : : /* Check whether there are new allocatable components. */
1779 : 5239 : for (comp = derived->components; comp; comp = comp->next)
1780 : : {
1781 : 3262 : if (comp == derived->components && derived->attr.extension
1782 : 324 : && ancestor_wrapper && ancestor_wrapper->expr_type != EXPR_NULL)
1783 : 172 : continue;
1784 : :
1785 : 3090 : finalizable_comp |= comp_is_finalizable (comp);
1786 : : }
1787 : :
1788 : : /* If there is no new finalizer and no new allocatable, return with
1789 : : an expr to the ancestor's one. */
1790 : 1977 : if (!finalizable_comp
1791 : 371 : && (!derived->f2k_derived || !derived->f2k_derived->finalizers))
1792 : : {
1793 : 57 : gcc_assert (ancestor_wrapper && ancestor_wrapper->ref == NULL
1794 : : && ancestor_wrapper->expr_type == EXPR_VARIABLE);
1795 : 57 : vtab_final->initializer = gfc_copy_expr (ancestor_wrapper);
1796 : 57 : vtab_final->ts.interface = vtab_final->initializer->symtree->n.sym;
1797 : 57 : return;
1798 : : }
1799 : :
1800 : : /* We now create a wrapper, which does the following:
1801 : : 1. Call the suitable finalization subroutine for this type
1802 : : 2. Loop over all noninherited allocatable components and noninherited
1803 : : components with allocatable components and DEALLOCATE those; this will
1804 : : take care of finalizers, coarray deregistering and allocatable
1805 : : nested components.
1806 : : 3. Call the ancestor's finalizer. */
1807 : :
1808 : : /* Declare the wrapper function; it takes an assumed-rank array
1809 : : and a VALUE logical as arguments. */
1810 : :
1811 : : /* Set up the namespace. */
1812 : 1920 : sub_ns = gfc_get_namespace (ns, 0);
1813 : 1920 : sub_ns->sibling = ns->contained;
1814 : 1920 : ns->contained = sub_ns;
1815 : 1920 : sub_ns->resolved = 1;
1816 : :
1817 : : /* Set up the procedure symbol. */
1818 : 1920 : name = xasprintf ("__final_%s", tname);
1819 : 1920 : gfc_get_symbol (name, sub_ns, &final);
1820 : 1920 : sub_ns->proc_name = final;
1821 : 1920 : final->attr.flavor = FL_PROCEDURE;
1822 : 1920 : final->attr.function = 1;
1823 : 1920 : final->attr.pure = 0;
1824 : 1920 : final->attr.recursive = 1;
1825 : 1920 : final->result = final;
1826 : 1920 : final->ts.type = BT_INTEGER;
1827 : 1920 : final->ts.kind = 4;
1828 : 1920 : final->attr.artificial = 1;
1829 : 1920 : final->attr.always_explicit = 1;
1830 : 1920 : final->attr.if_source = IFSRC_DECL;
1831 : 1920 : if (ns->proc_name->attr.flavor == FL_MODULE)
1832 : 1604 : final->module = ns->proc_name->name;
1833 : 1920 : gfc_set_sym_referenced (final);
1834 : 1920 : gfc_commit_symbol (final);
1835 : :
1836 : : /* Set up formal argument. */
1837 : 1920 : gfc_get_symbol ("array", sub_ns, &array);
1838 : 1920 : array->ts.type = BT_DERIVED;
1839 : 1920 : array->ts.u.derived = derived;
1840 : 1920 : array->attr.flavor = FL_VARIABLE;
1841 : 1920 : array->attr.dummy = 1;
1842 : 1920 : array->attr.contiguous = 1;
1843 : 1920 : array->attr.dimension = 1;
1844 : 1920 : array->attr.artificial = 1;
1845 : 1920 : array->as = gfc_get_array_spec();
1846 : 1920 : array->as->type = AS_ASSUMED_RANK;
1847 : 1920 : array->as->rank = -1;
1848 : 1920 : array->attr.intent = INTENT_INOUT;
1849 : 1920 : gfc_set_sym_referenced (array);
1850 : 1920 : final->formal = gfc_get_formal_arglist ();
1851 : 1920 : final->formal->sym = array;
1852 : 1920 : gfc_commit_symbol (array);
1853 : :
1854 : : /* Set up formal argument. */
1855 : 1920 : gfc_get_symbol ("byte_stride", sub_ns, &byte_stride);
1856 : 1920 : byte_stride->ts.type = BT_INTEGER;
1857 : 1920 : byte_stride->ts.kind = gfc_index_integer_kind;
1858 : 1920 : byte_stride->attr.flavor = FL_VARIABLE;
1859 : 1920 : byte_stride->attr.dummy = 1;
1860 : 1920 : byte_stride->attr.value = 1;
1861 : 1920 : byte_stride->attr.artificial = 1;
1862 : 1920 : gfc_set_sym_referenced (byte_stride);
1863 : 1920 : final->formal->next = gfc_get_formal_arglist ();
1864 : 1920 : final->formal->next->sym = byte_stride;
1865 : 1920 : gfc_commit_symbol (byte_stride);
1866 : :
1867 : : /* Set up formal argument. */
1868 : 1920 : gfc_get_symbol ("fini_coarray", sub_ns, &fini_coarray);
1869 : 1920 : fini_coarray->ts.type = BT_LOGICAL;
1870 : 1920 : fini_coarray->ts.kind = 1;
1871 : 1920 : fini_coarray->attr.flavor = FL_VARIABLE;
1872 : 1920 : fini_coarray->attr.dummy = 1;
1873 : 1920 : fini_coarray->attr.value = 1;
1874 : 1920 : fini_coarray->attr.artificial = 1;
1875 : 1920 : gfc_set_sym_referenced (fini_coarray);
1876 : 1920 : final->formal->next->next = gfc_get_formal_arglist ();
1877 : 1920 : final->formal->next->next->sym = fini_coarray;
1878 : 1920 : gfc_commit_symbol (fini_coarray);
1879 : :
1880 : : /* Local variables. */
1881 : :
1882 : 1920 : gfc_get_symbol ("idx", sub_ns, &idx);
1883 : 1920 : idx->ts.type = BT_INTEGER;
1884 : 1920 : idx->ts.kind = gfc_index_integer_kind;
1885 : 1920 : idx->attr.flavor = FL_VARIABLE;
1886 : 1920 : idx->attr.artificial = 1;
1887 : 1920 : gfc_set_sym_referenced (idx);
1888 : 1920 : gfc_commit_symbol (idx);
1889 : :
1890 : 1920 : gfc_get_symbol ("idx2", sub_ns, &idx2);
1891 : 1920 : idx2->ts.type = BT_INTEGER;
1892 : 1920 : idx2->ts.kind = gfc_index_integer_kind;
1893 : 1920 : idx2->attr.flavor = FL_VARIABLE;
1894 : 1920 : idx2->attr.artificial = 1;
1895 : 1920 : gfc_set_sym_referenced (idx2);
1896 : 1920 : gfc_commit_symbol (idx2);
1897 : :
1898 : 1920 : gfc_get_symbol ("offset", sub_ns, &offset);
1899 : 1920 : offset->ts.type = BT_INTEGER;
1900 : 1920 : offset->ts.kind = gfc_index_integer_kind;
1901 : 1920 : offset->attr.flavor = FL_VARIABLE;
1902 : 1920 : offset->attr.artificial = 1;
1903 : 1920 : gfc_set_sym_referenced (offset);
1904 : 1920 : gfc_commit_symbol (offset);
1905 : :
1906 : : /* Create RANK expression. */
1907 : 1920 : rank = gfc_build_intrinsic_call (sub_ns, GFC_ISYM_RANK, "rank",
1908 : : gfc_current_locus, 1,
1909 : : gfc_lval_expr_from_sym (array));
1910 : 1920 : if (rank->ts.kind != idx->ts.kind)
1911 : 1920 : gfc_convert_type_warn (rank, &idx->ts, 2, 0);
1912 : :
1913 : : /* Create is_contiguous variable. */
1914 : 1920 : gfc_get_symbol ("is_contiguous", sub_ns, &is_contiguous);
1915 : 1920 : is_contiguous->ts.type = BT_LOGICAL;
1916 : 1920 : is_contiguous->ts.kind = gfc_default_logical_kind;
1917 : 1920 : is_contiguous->attr.flavor = FL_VARIABLE;
1918 : 1920 : is_contiguous->attr.artificial = 1;
1919 : 1920 : gfc_set_sym_referenced (is_contiguous);
1920 : 1920 : gfc_commit_symbol (is_contiguous);
1921 : :
1922 : : /* Create "sizes(0..rank)" variable, which contains the multiplied
1923 : : up extent of the dimensions, i.e. sizes(0) = 1, sizes(1) = extent(dim=1),
1924 : : sizes(2) = sizes(1) * extent(dim=2) etc. */
1925 : 1920 : gfc_get_symbol ("sizes", sub_ns, &sizes);
1926 : 1920 : sizes->ts.type = BT_INTEGER;
1927 : 1920 : sizes->ts.kind = gfc_index_integer_kind;
1928 : 1920 : sizes->attr.flavor = FL_VARIABLE;
1929 : 1920 : sizes->attr.dimension = 1;
1930 : 1920 : sizes->attr.artificial = 1;
1931 : 1920 : sizes->as = gfc_get_array_spec();
1932 : 1920 : sizes->attr.intent = INTENT_INOUT;
1933 : 1920 : sizes->as->type = AS_EXPLICIT;
1934 : 1920 : sizes->as->rank = 1;
1935 : 1920 : sizes->as->lower[0] = gfc_get_int_expr (gfc_index_integer_kind, NULL, 0);
1936 : 1920 : sizes->as->upper[0] = gfc_copy_expr (rank);
1937 : 1920 : gfc_set_sym_referenced (sizes);
1938 : 1920 : gfc_commit_symbol (sizes);
1939 : :
1940 : : /* Create "strides(1..rank)" variable, which contains the strides per
1941 : : dimension. */
1942 : 1920 : gfc_get_symbol ("strides", sub_ns, &strides);
1943 : 1920 : strides->ts.type = BT_INTEGER;
1944 : 1920 : strides->ts.kind = gfc_index_integer_kind;
1945 : 1920 : strides->attr.flavor = FL_VARIABLE;
1946 : 1920 : strides->attr.dimension = 1;
1947 : 1920 : strides->attr.artificial = 1;
1948 : 1920 : strides->as = gfc_get_array_spec();
1949 : 1920 : strides->attr.intent = INTENT_INOUT;
1950 : 1920 : strides->as->type = AS_EXPLICIT;
1951 : 1920 : strides->as->rank = 1;
1952 : 1920 : strides->as->lower[0] = gfc_get_int_expr (gfc_index_integer_kind, NULL, 1);
1953 : 1920 : strides->as->upper[0] = gfc_copy_expr (rank);
1954 : 1920 : gfc_set_sym_referenced (strides);
1955 : 1920 : gfc_commit_symbol (strides);
1956 : :
1957 : :
1958 : : /* Set return value to 0. */
1959 : 1920 : last_code = gfc_get_code (EXEC_ASSIGN);
1960 : 1920 : last_code->expr1 = gfc_lval_expr_from_sym (final);
1961 : 1920 : last_code->expr2 = gfc_get_int_expr (4, NULL, 0);
1962 : 1920 : sub_ns->code = last_code;
1963 : :
1964 : : /* Set: is_contiguous = .true. */
1965 : 1920 : last_code->next = gfc_get_code (EXEC_ASSIGN);
1966 : 1920 : last_code = last_code->next;
1967 : 1920 : last_code->expr1 = gfc_lval_expr_from_sym (is_contiguous);
1968 : 1920 : last_code->expr2 = gfc_get_logical_expr (gfc_default_logical_kind,
1969 : : &gfc_current_locus, true);
1970 : :
1971 : : /* Set: sizes(0) = 1. */
1972 : 1920 : last_code->next = gfc_get_code (EXEC_ASSIGN);
1973 : 1920 : last_code = last_code->next;
1974 : 1920 : last_code->expr1 = gfc_lval_expr_from_sym (sizes);
1975 : 1920 : last_code->expr1->ref = gfc_get_ref ();
1976 : 1920 : last_code->expr1->ref->type = REF_ARRAY;
1977 : 1920 : last_code->expr1->ref->u.ar.type = AR_ELEMENT;
1978 : 1920 : last_code->expr1->ref->u.ar.dimen = 1;
1979 : 1920 : last_code->expr1->ref->u.ar.dimen_type[0] = DIMEN_ELEMENT;
1980 : 1920 : last_code->expr1->ref->u.ar.start[0]
1981 : 1920 : = gfc_get_int_expr (gfc_index_integer_kind, NULL, 0);
1982 : 1920 : last_code->expr1->ref->u.ar.as = sizes->as;
1983 : 1920 : last_code->expr2 = gfc_get_int_expr (gfc_default_integer_kind, NULL, 1);
1984 : :
1985 : : /* Create:
1986 : : DO idx = 1, rank
1987 : : strides(idx) = _F._stride (array, dim=idx)
1988 : : sizes(idx) = sizes(i-1) * size(array, dim=idx, kind=index_kind)
1989 : : if (strides (idx) /= sizes(i-1)) is_contiguous = .false.
1990 : : END DO. */
1991 : :
1992 : : /* Create loop. */
1993 : 1920 : iter = gfc_get_iterator ();
1994 : 1920 : iter->var = gfc_lval_expr_from_sym (idx);
1995 : 1920 : iter->start = gfc_get_int_expr (gfc_index_integer_kind, NULL, 1);
1996 : 1920 : iter->end = gfc_copy_expr (rank);
1997 : 1920 : iter->step = gfc_get_int_expr (gfc_index_integer_kind, NULL, 1);
1998 : 1920 : last_code->next = gfc_get_code (EXEC_DO);
1999 : 1920 : last_code = last_code->next;
2000 : 1920 : last_code->ext.iterator = iter;
2001 : 1920 : last_code->block = gfc_get_code (EXEC_DO);
2002 : :
2003 : : /* strides(idx) = _F._stride(array,dim=idx). */
2004 : 1920 : last_code->block->next = gfc_get_code (EXEC_ASSIGN);
2005 : 1920 : block = last_code->block->next;
2006 : :
2007 : 1920 : block->expr1 = gfc_lval_expr_from_sym (strides);
2008 : 1920 : block->expr1->ref = gfc_get_ref ();
2009 : 1920 : block->expr1->ref->type = REF_ARRAY;
2010 : 1920 : block->expr1->ref->u.ar.type = AR_ELEMENT;
2011 : 1920 : block->expr1->ref->u.ar.dimen = 1;
2012 : 1920 : block->expr1->ref->u.ar.dimen_type[0] = DIMEN_ELEMENT;
2013 : 1920 : block->expr1->ref->u.ar.start[0] = gfc_lval_expr_from_sym (idx);
2014 : 1920 : block->expr1->ref->u.ar.as = strides->as;
2015 : :
2016 : 1920 : block->expr2 = gfc_build_intrinsic_call (sub_ns, GFC_ISYM_STRIDE, "stride",
2017 : : gfc_current_locus, 2,
2018 : : gfc_lval_expr_from_sym (array),
2019 : : gfc_lval_expr_from_sym (idx));
2020 : :
2021 : : /* sizes(idx) = sizes(idx-1) * size(array,dim=idx, kind=index_kind). */
2022 : 1920 : block->next = gfc_get_code (EXEC_ASSIGN);
2023 : 1920 : block = block->next;
2024 : :
2025 : : /* sizes(idx) = ... */
2026 : 1920 : block->expr1 = gfc_lval_expr_from_sym (sizes);
2027 : 1920 : block->expr1->ref = gfc_get_ref ();
2028 : 1920 : block->expr1->ref->type = REF_ARRAY;
2029 : 1920 : block->expr1->ref->u.ar.type = AR_ELEMENT;
2030 : 1920 : block->expr1->ref->u.ar.dimen = 1;
2031 : 1920 : block->expr1->ref->u.ar.dimen_type[0] = DIMEN_ELEMENT;
2032 : 1920 : block->expr1->ref->u.ar.start[0] = gfc_lval_expr_from_sym (idx);
2033 : 1920 : block->expr1->ref->u.ar.as = sizes->as;
2034 : :
2035 : 1920 : block->expr2 = gfc_get_expr ();
2036 : 1920 : block->expr2->expr_type = EXPR_OP;
2037 : 1920 : block->expr2->value.op.op = INTRINSIC_TIMES;
2038 : 1920 : block->expr2->where = gfc_current_locus;
2039 : :
2040 : : /* sizes(idx-1). */
2041 : 1920 : block->expr2->value.op.op1 = gfc_lval_expr_from_sym (sizes);
2042 : 1920 : block->expr2->value.op.op1->ref = gfc_get_ref ();
2043 : 1920 : block->expr2->value.op.op1->ref->type = REF_ARRAY;
2044 : 1920 : block->expr2->value.op.op1->ref->u.ar.as = sizes->as;
2045 : 1920 : block->expr2->value.op.op1->ref->u.ar.type = AR_ELEMENT;
2046 : 1920 : block->expr2->value.op.op1->ref->u.ar.dimen = 1;
2047 : 1920 : block->expr2->value.op.op1->ref->u.ar.dimen_type[0] = DIMEN_ELEMENT;
2048 : 1920 : block->expr2->value.op.op1->ref->u.ar.start[0] = gfc_get_expr ();
2049 : 1920 : block->expr2->value.op.op1->ref->u.ar.start[0]->expr_type = EXPR_OP;
2050 : 1920 : block->expr2->value.op.op1->ref->u.ar.start[0]->where = gfc_current_locus;
2051 : 1920 : block->expr2->value.op.op1->ref->u.ar.start[0]->value.op.op = INTRINSIC_MINUS;
2052 : 1920 : block->expr2->value.op.op1->ref->u.ar.start[0]->value.op.op1
2053 : 1920 : = gfc_lval_expr_from_sym (idx);
2054 : 1920 : block->expr2->value.op.op1->ref->u.ar.start[0]->value.op.op2
2055 : 1920 : = gfc_get_int_expr (gfc_index_integer_kind, NULL, 1);
2056 : 1920 : block->expr2->value.op.op1->ref->u.ar.start[0]->ts
2057 : 1920 : = block->expr2->value.op.op1->ref->u.ar.start[0]->value.op.op1->ts;
2058 : :
2059 : : /* size(array, dim=idx, kind=index_kind). */
2060 : 3840 : block->expr2->value.op.op2
2061 : 1920 : = gfc_build_intrinsic_call (sub_ns, GFC_ISYM_SIZE, "size",
2062 : : gfc_current_locus, 3,
2063 : : gfc_lval_expr_from_sym (array),
2064 : : gfc_lval_expr_from_sym (idx),
2065 : : gfc_get_int_expr (gfc_index_integer_kind,
2066 : : NULL,
2067 : : gfc_index_integer_kind));
2068 : 1920 : block->expr2->value.op.op2->ts.kind = gfc_index_integer_kind;
2069 : 1920 : block->expr2->ts = idx->ts;
2070 : :
2071 : : /* if (strides (idx) /= sizes(idx-1)) is_contiguous = .false. */
2072 : 1920 : block->next = gfc_get_code (EXEC_IF);
2073 : 1920 : block = block->next;
2074 : :
2075 : 1920 : block->block = gfc_get_code (EXEC_IF);
2076 : 1920 : block = block->block;
2077 : :
2078 : : /* if condition: strides(idx) /= sizes(idx-1). */
2079 : 1920 : block->expr1 = gfc_get_expr ();
2080 : 1920 : block->expr1->ts.type = BT_LOGICAL;
2081 : 1920 : block->expr1->ts.kind = gfc_default_logical_kind;
2082 : 1920 : block->expr1->expr_type = EXPR_OP;
2083 : 1920 : block->expr1->where = gfc_current_locus;
2084 : 1920 : block->expr1->value.op.op = INTRINSIC_NE;
2085 : :
2086 : 1920 : block->expr1->value.op.op1 = gfc_lval_expr_from_sym (strides);
2087 : 1920 : block->expr1->value.op.op1->ref = gfc_get_ref ();
2088 : 1920 : block->expr1->value.op.op1->ref->type = REF_ARRAY;
2089 : 1920 : block->expr1->value.op.op1->ref->u.ar.type = AR_ELEMENT;
2090 : 1920 : block->expr1->value.op.op1->ref->u.ar.dimen = 1;
2091 : 1920 : block->expr1->value.op.op1->ref->u.ar.dimen_type[0] = DIMEN_ELEMENT;
2092 : 1920 : block->expr1->value.op.op1->ref->u.ar.start[0] = gfc_lval_expr_from_sym (idx);
2093 : 1920 : block->expr1->value.op.op1->ref->u.ar.as = strides->as;
2094 : :
2095 : 1920 : block->expr1->value.op.op2 = gfc_lval_expr_from_sym (sizes);
2096 : 1920 : block->expr1->value.op.op2->ref = gfc_get_ref ();
2097 : 1920 : block->expr1->value.op.op2->ref->type = REF_ARRAY;
2098 : 1920 : block->expr1->value.op.op2->ref->u.ar.as = sizes->as;
2099 : 1920 : block->expr1->value.op.op2->ref->u.ar.type = AR_ELEMENT;
2100 : 1920 : block->expr1->value.op.op2->ref->u.ar.dimen = 1;
2101 : 1920 : block->expr1->value.op.op2->ref->u.ar.dimen_type[0] = DIMEN_ELEMENT;
2102 : 1920 : block->expr1->value.op.op2->ref->u.ar.start[0] = gfc_get_expr ();
2103 : 1920 : block->expr1->value.op.op2->ref->u.ar.start[0]->expr_type = EXPR_OP;
2104 : 1920 : block->expr1->value.op.op2->ref->u.ar.start[0]->where = gfc_current_locus;
2105 : 1920 : block->expr1->value.op.op2->ref->u.ar.start[0]->value.op.op = INTRINSIC_MINUS;
2106 : 1920 : block->expr1->value.op.op2->ref->u.ar.start[0]->value.op.op1
2107 : 1920 : = gfc_lval_expr_from_sym (idx);
2108 : 1920 : block->expr1->value.op.op2->ref->u.ar.start[0]->value.op.op2
2109 : 1920 : = gfc_get_int_expr (gfc_index_integer_kind, NULL, 1);
2110 : 1920 : block->expr1->value.op.op2->ref->u.ar.start[0]->ts
2111 : 1920 : = block->expr1->value.op.op2->ref->u.ar.start[0]->value.op.op1->ts;
2112 : :
2113 : : /* if body: is_contiguous = .false. */
2114 : 1920 : block->next = gfc_get_code (EXEC_ASSIGN);
2115 : 1920 : block = block->next;
2116 : 1920 : block->expr1 = gfc_lval_expr_from_sym (is_contiguous);
2117 : 1920 : block->expr2 = gfc_get_logical_expr (gfc_default_logical_kind,
2118 : : &gfc_current_locus, false);
2119 : :
2120 : : /* Obtain the size (number of elements) of "array" MINUS ONE,
2121 : : which is used in the scalarization. */
2122 : 1920 : gfc_get_symbol ("nelem", sub_ns, &nelem);
2123 : 1920 : nelem->ts.type = BT_INTEGER;
2124 : 1920 : nelem->ts.kind = gfc_index_integer_kind;
2125 : 1920 : nelem->attr.flavor = FL_VARIABLE;
2126 : 1920 : nelem->attr.artificial = 1;
2127 : 1920 : gfc_set_sym_referenced (nelem);
2128 : 1920 : gfc_commit_symbol (nelem);
2129 : :
2130 : : /* nelem = sizes (rank) - 1. */
2131 : 1920 : last_code->next = gfc_get_code (EXEC_ASSIGN);
2132 : 1920 : last_code = last_code->next;
2133 : :
2134 : 1920 : last_code->expr1 = gfc_lval_expr_from_sym (nelem);
2135 : :
2136 : 1920 : last_code->expr2 = gfc_get_expr ();
2137 : 1920 : last_code->expr2->expr_type = EXPR_OP;
2138 : 1920 : last_code->expr2->value.op.op = INTRINSIC_MINUS;
2139 : 1920 : last_code->expr2->value.op.op2
2140 : 1920 : = gfc_get_int_expr (gfc_index_integer_kind, NULL, 1);
2141 : 1920 : last_code->expr2->ts = last_code->expr2->value.op.op2->ts;
2142 : 1920 : last_code->expr2->where = gfc_current_locus;
2143 : :
2144 : 1920 : last_code->expr2->value.op.op1 = gfc_lval_expr_from_sym (sizes);
2145 : 1920 : last_code->expr2->value.op.op1->ref = gfc_get_ref ();
2146 : 1920 : last_code->expr2->value.op.op1->ref->type = REF_ARRAY;
2147 : 1920 : last_code->expr2->value.op.op1->ref->u.ar.type = AR_ELEMENT;
2148 : 1920 : last_code->expr2->value.op.op1->ref->u.ar.dimen = 1;
2149 : 1920 : last_code->expr2->value.op.op1->ref->u.ar.dimen_type[0] = DIMEN_ELEMENT;
2150 : 1920 : last_code->expr2->value.op.op1->ref->u.ar.start[0] = gfc_copy_expr (rank);
2151 : 1920 : last_code->expr2->value.op.op1->ref->u.ar.as = sizes->as;
2152 : :
2153 : : /* Call final subroutines. We now generate code like:
2154 : : use iso_c_binding
2155 : : integer, pointer :: ptr
2156 : : type(c_ptr) :: cptr
2157 : : integer(c_intptr_t) :: i, addr
2158 : :
2159 : : select case (rank (array))
2160 : : case (3)
2161 : : ! If needed, the array is packed
2162 : : call final_rank3 (array)
2163 : : case default:
2164 : : do i = 0, size (array)-1
2165 : : addr = transfer (c_loc (array), addr) + i * stride
2166 : : call c_f_pointer (transfer (addr, cptr), ptr)
2167 : : call elemental_final (ptr)
2168 : : end do
2169 : : end select */
2170 : :
2171 : 1920 : if (derived->f2k_derived && derived->f2k_derived->finalizers)
2172 : : {
2173 : 372 : gfc_finalizer *fini, *fini_elem = NULL;
2174 : :
2175 : 372 : gfc_get_symbol ("ptr1", sub_ns, &ptr);
2176 : 372 : ptr->ts.type = BT_DERIVED;
2177 : 372 : ptr->ts.u.derived = derived;
2178 : 372 : ptr->attr.flavor = FL_VARIABLE;
2179 : 372 : ptr->attr.pointer = 1;
2180 : 372 : ptr->attr.artificial = 1;
2181 : 372 : gfc_set_sym_referenced (ptr);
2182 : 372 : gfc_commit_symbol (ptr);
2183 : :
2184 : 372 : fini = derived->f2k_derived->finalizers;
2185 : :
2186 : : /* Assumed rank finalizers can be called directly. The call takes care
2187 : : of setting up the descriptor. resolve_finalizers has already checked
2188 : : that this is the only finalizer for this kind/type (F2018: C790). */
2189 : 372 : if (fini->proc_tree && fini->proc_tree->n.sym->formal->sym->as
2190 : 100 : && fini->proc_tree->n.sym->formal->sym->as->type == AS_ASSUMED_RANK)
2191 : : {
2192 : 6 : last_code->next = gfc_get_code (EXEC_CALL);
2193 : 6 : last_code->next->symtree = fini->proc_tree;
2194 : 6 : last_code->next->resolved_sym = fini->proc_tree->n.sym;
2195 : 6 : last_code->next->ext.actual = gfc_get_actual_arglist ();
2196 : 6 : last_code->next->ext.actual->expr = gfc_lval_expr_from_sym (array);
2197 : :
2198 : 6 : last_code = last_code->next;
2199 : 6 : goto finish_assumed_rank;
2200 : : }
2201 : :
2202 : : /* SELECT CASE (RANK (array)). */
2203 : 366 : last_code->next = gfc_get_code (EXEC_SELECT);
2204 : 366 : last_code = last_code->next;
2205 : 366 : last_code->expr1 = gfc_copy_expr (rank);
2206 : 366 : block = NULL;
2207 : :
2208 : :
2209 : 809 : for (; fini; fini = fini->next)
2210 : : {
2211 : 443 : gcc_assert (fini->proc_tree); /* Should have been set in gfc_resolve_finalizers. */
2212 : 443 : if (fini->proc_tree->n.sym->attr.elemental)
2213 : : {
2214 : 102 : fini_elem = fini;
2215 : 102 : continue;
2216 : : }
2217 : :
2218 : : /* CASE (fini_rank). */
2219 : 341 : if (block)
2220 : : {
2221 : 64 : block->block = gfc_get_code (EXEC_SELECT);
2222 : 64 : block = block->block;
2223 : : }
2224 : : else
2225 : : {
2226 : 277 : block = gfc_get_code (EXEC_SELECT);
2227 : 277 : last_code->block = block;
2228 : : }
2229 : 341 : block->ext.block.case_list = gfc_get_case ();
2230 : 341 : block->ext.block.case_list->where = gfc_current_locus;
2231 : 341 : if (fini->proc_tree->n.sym->formal->sym->attr.dimension)
2232 : 114 : block->ext.block.case_list->low
2233 : 114 : = gfc_get_int_expr (gfc_default_integer_kind, NULL,
2234 : 114 : fini->proc_tree->n.sym->formal->sym->as->rank);
2235 : : else
2236 : 227 : block->ext.block.case_list->low
2237 : 227 : = gfc_get_int_expr (gfc_default_integer_kind, NULL, 0);
2238 : 341 : block->ext.block.case_list->high
2239 : 341 : = gfc_copy_expr (block->ext.block.case_list->low);
2240 : :
2241 : : /* CALL fini_rank (array) - possibly with packing. */
2242 : 341 : if (fini->proc_tree->n.sym->formal->sym->attr.dimension)
2243 : 114 : finalizer_insert_packed_call (block, fini, array, byte_stride,
2244 : : idx, ptr, nelem, strides,
2245 : : sizes, idx2, offset, is_contiguous,
2246 : : rank, sub_ns);
2247 : : else
2248 : : {
2249 : 227 : block->next = gfc_get_code (EXEC_CALL);
2250 : 227 : block->next->symtree = fini->proc_tree;
2251 : 227 : block->next->resolved_sym = fini->proc_tree->n.sym;
2252 : 227 : block->next->ext.actual = gfc_get_actual_arglist ();
2253 : 227 : block->next->ext.actual->expr = gfc_lval_expr_from_sym (array);
2254 : : }
2255 : : }
2256 : :
2257 : : /* Elemental call - scalarized. */
2258 : 366 : if (fini_elem)
2259 : : {
2260 : : /* CASE DEFAULT. */
2261 : 102 : if (block)
2262 : : {
2263 : 13 : block->block = gfc_get_code (EXEC_SELECT);
2264 : 13 : block = block->block;
2265 : : }
2266 : : else
2267 : : {
2268 : 89 : block = gfc_get_code (EXEC_SELECT);
2269 : 89 : last_code->block = block;
2270 : : }
2271 : 102 : block->ext.block.case_list = gfc_get_case ();
2272 : :
2273 : : /* Create loop. */
2274 : 102 : iter = gfc_get_iterator ();
2275 : 102 : iter->var = gfc_lval_expr_from_sym (idx);
2276 : 102 : iter->start = gfc_get_int_expr (gfc_index_integer_kind, NULL, 0);
2277 : 102 : iter->end = gfc_lval_expr_from_sym (nelem);
2278 : 102 : iter->step = gfc_get_int_expr (gfc_index_integer_kind, NULL, 1);
2279 : 102 : block->next = gfc_get_code (EXEC_DO);
2280 : 102 : block = block->next;
2281 : 102 : block->ext.iterator = iter;
2282 : 102 : block->block = gfc_get_code (EXEC_DO);
2283 : :
2284 : : /* Offset calculation. */
2285 : 102 : block = finalization_get_offset (idx, idx2, offset, strides, sizes,
2286 : : byte_stride, rank, block->block,
2287 : : sub_ns);
2288 : :
2289 : : /* Create code for
2290 : : CALL C_F_POINTER (TRANSFER (TRANSFER (C_LOC (array, cptr), c_intptr)
2291 : : + offset, c_ptr), ptr). */
2292 : 102 : block->next
2293 : 102 : = finalization_scalarizer (array, ptr,
2294 : : gfc_lval_expr_from_sym (offset),
2295 : : sub_ns);
2296 : 102 : block = block->next;
2297 : :
2298 : : /* CALL final_elemental (array). */
2299 : 102 : block->next = gfc_get_code (EXEC_CALL);
2300 : 102 : block = block->next;
2301 : 102 : block->symtree = fini_elem->proc_tree;
2302 : 102 : block->resolved_sym = fini_elem->proc_sym;
2303 : 102 : block->ext.actual = gfc_get_actual_arglist ();
2304 : 102 : block->ext.actual->expr = gfc_lval_expr_from_sym (ptr);
2305 : : }
2306 : : }
2307 : :
2308 : 1548 : finish_assumed_rank:
2309 : :
2310 : : /* Finalize and deallocate allocatable components. The same manual
2311 : : scalarization is used as above. */
2312 : :
2313 : 1920 : if (finalizable_comp)
2314 : : {
2315 : 1606 : gfc_symbol *stat;
2316 : 1606 : gfc_code *block = NULL;
2317 : :
2318 : 1606 : if (!ptr)
2319 : : {
2320 : 1548 : gfc_get_symbol ("ptr2", sub_ns, &ptr);
2321 : 1548 : ptr->ts.type = BT_DERIVED;
2322 : 1548 : ptr->ts.u.derived = derived;
2323 : 1548 : ptr->attr.flavor = FL_VARIABLE;
2324 : 1548 : ptr->attr.pointer = 1;
2325 : 1548 : ptr->attr.artificial = 1;
2326 : 1548 : gfc_set_sym_referenced (ptr);
2327 : 1548 : gfc_commit_symbol (ptr);
2328 : : }
2329 : :
2330 : 1606 : gfc_get_symbol ("ignore", sub_ns, &stat);
2331 : 1606 : stat->attr.flavor = FL_VARIABLE;
2332 : 1606 : stat->attr.artificial = 1;
2333 : 1606 : stat->ts.type = BT_INTEGER;
2334 : 1606 : stat->ts.kind = gfc_default_integer_kind;
2335 : 1606 : gfc_set_sym_referenced (stat);
2336 : 1606 : gfc_commit_symbol (stat);
2337 : :
2338 : : /* Create loop. */
2339 : 1606 : iter = gfc_get_iterator ();
2340 : 1606 : iter->var = gfc_lval_expr_from_sym (idx);
2341 : 1606 : iter->start = gfc_get_int_expr (gfc_index_integer_kind, NULL, 0);
2342 : 1606 : iter->end = gfc_lval_expr_from_sym (nelem);
2343 : 1606 : iter->step = gfc_get_int_expr (gfc_index_integer_kind, NULL, 1);
2344 : 1606 : last_code->next = gfc_get_code (EXEC_DO);
2345 : 1606 : last_code = last_code->next;
2346 : 1606 : last_code->ext.iterator = iter;
2347 : 1606 : last_code->block = gfc_get_code (EXEC_DO);
2348 : :
2349 : : /* Offset calculation. */
2350 : 1606 : block = finalization_get_offset (idx, idx2, offset, strides, sizes,
2351 : : byte_stride, rank, last_code->block,
2352 : : sub_ns);
2353 : :
2354 : : /* Create code for
2355 : : CALL C_F_POINTER (TRANSFER (TRANSFER (C_LOC (array, cptr), c_intptr)
2356 : : + idx * stride, c_ptr), ptr). */
2357 : 1606 : block->next = finalization_scalarizer (array, ptr,
2358 : : gfc_lval_expr_from_sym(offset),
2359 : : sub_ns);
2360 : 1606 : block = block->next;
2361 : :
2362 : 4419 : for (comp = derived->components; comp; comp = comp->next)
2363 : : {
2364 : 2813 : if (comp == derived->components && derived->attr.extension
2365 : 206 : && ancestor_wrapper && ancestor_wrapper->expr_type != EXPR_NULL)
2366 : 54 : continue;
2367 : :
2368 : 2759 : finalize_component (gfc_lval_expr_from_sym (ptr), derived, comp,
2369 : : stat, fini_coarray, &block, sub_ns);
2370 : 2759 : if (!last_code->block->next)
2371 : 0 : last_code->block->next = block;
2372 : : }
2373 : :
2374 : : }
2375 : :
2376 : : /* Call the finalizer of the ancestor. */
2377 : 1920 : if (ancestor_wrapper && ancestor_wrapper->expr_type != EXPR_NULL)
2378 : : {
2379 : 115 : last_code->next = gfc_get_code (EXEC_CALL);
2380 : 115 : last_code = last_code->next;
2381 : 115 : last_code->symtree = ancestor_wrapper->symtree;
2382 : 115 : last_code->resolved_sym = ancestor_wrapper->symtree->n.sym;
2383 : :
2384 : 115 : last_code->ext.actual = gfc_get_actual_arglist ();
2385 : 115 : last_code->ext.actual->expr = gfc_lval_expr_from_sym (array);
2386 : 115 : last_code->ext.actual->next = gfc_get_actual_arglist ();
2387 : 115 : last_code->ext.actual->next->expr = gfc_lval_expr_from_sym (byte_stride);
2388 : 115 : last_code->ext.actual->next->next = gfc_get_actual_arglist ();
2389 : 115 : last_code->ext.actual->next->next->expr
2390 : 115 : = gfc_lval_expr_from_sym (fini_coarray);
2391 : : }
2392 : :
2393 : 1920 : gfc_free_expr (rank);
2394 : 1920 : vtab_final->initializer = gfc_lval_expr_from_sym (final);
2395 : 1920 : vtab_final->ts.interface = final;
2396 : 1920 : free (name);
2397 : : }
2398 : :
2399 : :
2400 : : /* Add procedure pointers for all type-bound procedures to a vtab. */
2401 : :
2402 : : static void
2403 : 10423 : add_procs_to_declared_vtab (gfc_symbol *derived, gfc_symbol *vtype)
2404 : : {
2405 : 10423 : gfc_symbol* super_type;
2406 : :
2407 : 10423 : super_type = gfc_get_derived_super_type (derived);
2408 : :
2409 : 10423 : if (super_type && (super_type != derived))
2410 : : {
2411 : : /* Make sure that the PPCs appear in the same order as in the parent. */
2412 : 1421 : copy_vtab_proc_comps (super_type, vtype);
2413 : : /* Only needed to get the PPC initializers right. */
2414 : 1421 : add_procs_to_declared_vtab (super_type, vtype);
2415 : : }
2416 : :
2417 : 10423 : if (derived->f2k_derived && derived->f2k_derived->tb_sym_root)
2418 : 2198 : add_procs_to_declared_vtab1 (derived->f2k_derived->tb_sym_root, vtype);
2419 : :
2420 : 10423 : if (derived->f2k_derived && derived->f2k_derived->tb_uop_root)
2421 : 22 : add_procs_to_declared_vtab1 (derived->f2k_derived->tb_uop_root, vtype);
2422 : 10423 : }
2423 : :
2424 : :
2425 : : /* Find or generate the symbol for a derived type's vtab. */
2426 : :
2427 : : gfc_symbol *
2428 : 73961 : gfc_find_derived_vtab (gfc_symbol *derived)
2429 : : {
2430 : 73961 : gfc_namespace *ns;
2431 : 73961 : gfc_symbol *vtab = NULL, *vtype = NULL, *found_sym = NULL, *def_init = NULL;
2432 : 73961 : gfc_symbol *copy = NULL, *src = NULL, *dst = NULL;
2433 : 73961 : gfc_gsymbol *gsym = NULL;
2434 : 73961 : gfc_symbol *dealloc = NULL, *arg = NULL;
2435 : :
2436 : 73961 : if (derived->attr.pdt_template)
2437 : : return NULL;
2438 : :
2439 : : /* Find the top-level namespace. */
2440 : 82960 : for (ns = gfc_current_ns; ns; ns = ns->parent)
2441 : 82960 : if (!ns->parent)
2442 : : break;
2443 : :
2444 : : /* If the type is a class container, use the underlying derived type. */
2445 : 73947 : if (!derived->attr.unlimited_polymorphic && derived->attr.is_class)
2446 : 9893 : derived = gfc_get_derived_super_type (derived);
2447 : :
2448 : 9893 : if (!derived)
2449 : : return NULL;
2450 : :
2451 : 73947 : if (!derived->name)
2452 : : return NULL;
2453 : :
2454 : : /* Find the gsymbol for the module of use associated derived types. */
2455 : 73947 : if ((derived->attr.use_assoc || derived->attr.used_in_submodule)
2456 : 33697 : && !derived->attr.vtype && !derived->attr.is_class)
2457 : 33697 : gsym = gfc_find_gsymbol (gfc_gsym_root, derived->module);
2458 : : else
2459 : : gsym = NULL;
2460 : :
2461 : : /* Work in the gsymbol namespace if the top-level namespace is a module.
2462 : : This ensures that the vtable is unique, which is required since we use
2463 : : its address in SELECT TYPE. */
2464 : 33697 : if (gsym && gsym->ns && ns && ns->proc_name
2465 : 25340 : && ns->proc_name->attr.flavor == FL_MODULE)
2466 : : ns = gsym->ns;
2467 : :
2468 : 53476 : if (ns)
2469 : : {
2470 : 73947 : char tname[GFC_MAX_SYMBOL_LEN+1];
2471 : 73947 : char *name;
2472 : :
2473 : 73947 : get_unique_hashed_string (tname, derived);
2474 : 73947 : name = xasprintf ("__vtab_%s", tname);
2475 : :
2476 : : /* Look for the vtab symbol in various namespaces. */
2477 : 73947 : if (gsym && gsym->ns)
2478 : : {
2479 : 25340 : gfc_find_symbol (name, gsym->ns, 0, &vtab);
2480 : 25340 : if (vtab)
2481 : 24943 : ns = gsym->ns;
2482 : : }
2483 : 73947 : if (vtab == NULL)
2484 : 49004 : gfc_find_symbol (name, gfc_current_ns, 0, &vtab);
2485 : 73947 : if (vtab == NULL)
2486 : 15406 : gfc_find_symbol (name, ns, 0, &vtab);
2487 : 73947 : if (vtab == NULL)
2488 : 9719 : gfc_find_symbol (name, derived->ns, 0, &vtab);
2489 : :
2490 : 73947 : if (vtab == NULL)
2491 : : {
2492 : 9713 : gfc_get_symbol (name, ns, &vtab);
2493 : 9713 : vtab->ts.type = BT_DERIVED;
2494 : 9713 : if (!gfc_add_flavor (&vtab->attr, FL_VARIABLE, NULL,
2495 : : &gfc_current_locus))
2496 : 0 : goto cleanup;
2497 : 9713 : vtab->attr.target = 1;
2498 : 9713 : vtab->attr.save = SAVE_IMPLICIT;
2499 : 9713 : vtab->attr.vtab = 1;
2500 : 9713 : vtab->attr.access = ACCESS_PUBLIC;
2501 : 9713 : vtab->attr.artificial = 1;
2502 : 9713 : gfc_set_sym_referenced (vtab);
2503 : 9713 : free (name);
2504 : 9713 : name = xasprintf ("__vtype_%s", tname);
2505 : :
2506 : 9713 : gfc_find_symbol (name, ns, 0, &vtype);
2507 : 9713 : if (vtype == NULL)
2508 : : {
2509 : 9713 : gfc_component *c;
2510 : 9713 : gfc_symbol *parent = NULL, *parent_vtab = NULL;
2511 : :
2512 : 9713 : gfc_get_symbol (name, ns, &vtype);
2513 : 9713 : if (!gfc_add_flavor (&vtype->attr, FL_DERIVED, NULL,
2514 : : &gfc_current_locus))
2515 : 0 : goto cleanup;
2516 : 9713 : vtype->attr.access = ACCESS_PUBLIC;
2517 : 9713 : vtype->attr.vtype = 1;
2518 : 9713 : gfc_set_sym_referenced (vtype);
2519 : :
2520 : : /* Add component '_hash'. */
2521 : 9713 : if (!gfc_add_component (vtype, "_hash", &c))
2522 : 0 : goto cleanup;
2523 : 9713 : c->ts.type = BT_INTEGER;
2524 : 9713 : c->ts.kind = 4;
2525 : 9713 : c->attr.access = ACCESS_PRIVATE;
2526 : 19426 : c->initializer = gfc_get_int_expr (gfc_default_integer_kind,
2527 : 9713 : NULL, derived->hash_value);
2528 : :
2529 : : /* Add component '_size'. */
2530 : 9713 : if (!gfc_add_component (vtype, "_size", &c))
2531 : 0 : goto cleanup;
2532 : 9713 : c->ts.type = BT_INTEGER;
2533 : 9713 : c->ts.kind = gfc_size_kind;
2534 : 9713 : c->attr.access = ACCESS_PRIVATE;
2535 : : /* Remember the derived type in ts.u.derived,
2536 : : so that the correct initializer can be set later on
2537 : : (in gfc_conv_structure). */
2538 : 9713 : c->ts.u.derived = derived;
2539 : 9713 : c->initializer = gfc_get_int_expr (gfc_size_kind,
2540 : : NULL, 0);
2541 : :
2542 : : /* Add component _extends. */
2543 : 9713 : if (!gfc_add_component (vtype, "_extends", &c))
2544 : 0 : goto cleanup;
2545 : 9713 : c->attr.pointer = 1;
2546 : 9713 : c->attr.access = ACCESS_PRIVATE;
2547 : 9713 : if (!derived->attr.unlimited_polymorphic)
2548 : 9006 : parent = gfc_get_derived_super_type (derived);
2549 : : else
2550 : : parent = NULL;
2551 : :
2552 : 9006 : if (parent)
2553 : : {
2554 : 1302 : parent_vtab = gfc_find_derived_vtab (parent);
2555 : 1302 : c->ts.type = BT_DERIVED;
2556 : 1302 : c->ts.u.derived = parent_vtab->ts.u.derived;
2557 : 1302 : c->initializer = gfc_get_expr ();
2558 : 1302 : c->initializer->expr_type = EXPR_VARIABLE;
2559 : 1302 : gfc_find_sym_tree (parent_vtab->name, parent_vtab->ns,
2560 : : 0, &c->initializer->symtree);
2561 : : }
2562 : : else
2563 : : {
2564 : 8411 : c->ts.type = BT_DERIVED;
2565 : 8411 : c->ts.u.derived = vtype;
2566 : 8411 : c->initializer = gfc_get_null_expr (NULL);
2567 : : }
2568 : :
2569 : 9713 : if (!derived->attr.unlimited_polymorphic
2570 : 9006 : && derived->components == NULL
2571 : 1055 : && !derived->attr.zero_comp)
2572 : : {
2573 : : /* At this point an error must have occurred.
2574 : : Prevent further errors on the vtype components. */
2575 : 4 : found_sym = vtab;
2576 : 4 : goto have_vtype;
2577 : : }
2578 : :
2579 : : /* Add component _def_init. */
2580 : 9709 : if (!gfc_add_component (vtype, "_def_init", &c))
2581 : 0 : goto cleanup;
2582 : 9709 : c->attr.pointer = 1;
2583 : 9709 : c->attr.artificial = 1;
2584 : 9709 : c->attr.access = ACCESS_PRIVATE;
2585 : 9709 : c->ts.type = BT_DERIVED;
2586 : 9709 : c->ts.u.derived = derived;
2587 : 9709 : if (derived->attr.unlimited_polymorphic
2588 : 9709 : || derived->attr.abstract)
2589 : 1012 : c->initializer = gfc_get_null_expr (NULL);
2590 : : else
2591 : : {
2592 : : /* Construct default initialization variable. */
2593 : 8697 : free (name);
2594 : 8697 : name = xasprintf ("__def_init_%s", tname);
2595 : 8697 : gfc_get_symbol (name, ns, &def_init);
2596 : 8697 : def_init->attr.target = 1;
2597 : 8697 : def_init->attr.artificial = 1;
2598 : 8697 : def_init->attr.save = SAVE_IMPLICIT;
2599 : 8697 : def_init->attr.access = ACCESS_PUBLIC;
2600 : 8697 : def_init->attr.flavor = FL_VARIABLE;
2601 : 8697 : gfc_set_sym_referenced (def_init);
2602 : 8697 : def_init->ts.type = BT_DERIVED;
2603 : 8697 : def_init->ts.u.derived = derived;
2604 : 8697 : def_init->value = gfc_default_initializer (&def_init->ts);
2605 : :
2606 : 8697 : c->initializer = gfc_lval_expr_from_sym (def_init);
2607 : : }
2608 : :
2609 : : /* Add component _copy. */
2610 : 9709 : if (!gfc_add_component (vtype, "_copy", &c))
2611 : 0 : goto cleanup;
2612 : 9709 : c->attr.proc_pointer = 1;
2613 : 9709 : c->attr.access = ACCESS_PRIVATE;
2614 : 9709 : c->attr.artificial = 1;
2615 : 9709 : c->tb = XCNEW (gfc_typebound_proc);
2616 : 9709 : c->tb->ppc = 1;
2617 : 9709 : if (derived->attr.unlimited_polymorphic
2618 : 9709 : || derived->attr.abstract)
2619 : 1012 : c->initializer = gfc_get_null_expr (NULL);
2620 : : else
2621 : : {
2622 : : /* Set up namespace. */
2623 : 8697 : gfc_namespace *sub_ns = gfc_get_namespace (ns, 0);
2624 : 8697 : sub_ns->sibling = ns->contained;
2625 : 8697 : ns->contained = sub_ns;
2626 : 8697 : sub_ns->resolved = 1;
2627 : : /* Set up procedure symbol. */
2628 : 8697 : free (name);
2629 : 8697 : name = xasprintf ("__copy_%s", tname);
2630 : 8697 : gfc_get_symbol (name, sub_ns, ©);
2631 : 8697 : sub_ns->proc_name = copy;
2632 : 8697 : copy->attr.flavor = FL_PROCEDURE;
2633 : 8697 : copy->attr.subroutine = 1;
2634 : 8697 : copy->attr.pure = 1;
2635 : 8697 : copy->attr.artificial = 1;
2636 : 8697 : copy->attr.if_source = IFSRC_DECL;
2637 : : /* This is elemental so that arrays are automatically
2638 : : treated correctly by the scalarizer. */
2639 : 8697 : copy->attr.elemental = 1;
2640 : 8697 : if (ns->proc_name->attr.flavor == FL_MODULE)
2641 : 7089 : copy->module = ns->proc_name->name;
2642 : 8697 : gfc_set_sym_referenced (copy);
2643 : : /* Set up formal arguments. */
2644 : 8697 : gfc_get_symbol ("src", sub_ns, &src);
2645 : 8697 : src->ts.type = BT_DERIVED;
2646 : 8697 : src->ts.u.derived = derived;
2647 : 8697 : src->attr.flavor = FL_VARIABLE;
2648 : 8697 : src->attr.dummy = 1;
2649 : 8697 : src->attr.artificial = 1;
2650 : 8697 : src->attr.intent = INTENT_IN;
2651 : 8697 : gfc_set_sym_referenced (src);
2652 : 8697 : copy->formal = gfc_get_formal_arglist ();
2653 : 8697 : copy->formal->sym = src;
2654 : 8697 : gfc_get_symbol ("dst", sub_ns, &dst);
2655 : 8697 : dst->ts.type = BT_DERIVED;
2656 : 8697 : dst->ts.u.derived = derived;
2657 : 8697 : dst->attr.flavor = FL_VARIABLE;
2658 : 8697 : dst->attr.dummy = 1;
2659 : 8697 : dst->attr.artificial = 1;
2660 : 8697 : dst->attr.intent = INTENT_INOUT;
2661 : 8697 : gfc_set_sym_referenced (dst);
2662 : 8697 : copy->formal->next = gfc_get_formal_arglist ();
2663 : 8697 : copy->formal->next->sym = dst;
2664 : : /* Set up code. */
2665 : 8697 : sub_ns->code = gfc_get_code (EXEC_INIT_ASSIGN);
2666 : 8697 : sub_ns->code->expr1 = gfc_lval_expr_from_sym (dst);
2667 : 8697 : sub_ns->code->expr2 = gfc_lval_expr_from_sym (src);
2668 : : /* Set initializer. */
2669 : 8697 : c->initializer = gfc_lval_expr_from_sym (copy);
2670 : 8697 : c->ts.interface = copy;
2671 : : }
2672 : :
2673 : : /* Add component _final, which contains a procedure pointer to
2674 : : a wrapper which handles both the freeing of allocatable
2675 : : components and the calls to finalization subroutines.
2676 : : Note: The actual wrapper function can only be generated
2677 : : at resolution time. */
2678 : 9709 : if (!gfc_add_component (vtype, "_final", &c))
2679 : 0 : goto cleanup;
2680 : 9709 : c->attr.proc_pointer = 1;
2681 : 9709 : c->attr.access = ACCESS_PRIVATE;
2682 : 9709 : c->attr.artificial = 1;
2683 : 9709 : c->tb = XCNEW (gfc_typebound_proc);
2684 : 9709 : c->tb->ppc = 1;
2685 : 9709 : generate_finalization_wrapper (derived, ns, tname, c);
2686 : :
2687 : : /* Add component _deallocate. */
2688 : 9709 : if (!gfc_add_component (vtype, "_deallocate", &c))
2689 : 0 : goto cleanup;
2690 : 9709 : c->attr.proc_pointer = 1;
2691 : 9709 : c->attr.access = ACCESS_PRIVATE;
2692 : 9709 : c->attr.artificial = 1;
2693 : 9709 : c->tb = XCNEW (gfc_typebound_proc);
2694 : 9709 : c->tb->ppc = 1;
2695 : 9709 : if (derived->attr.unlimited_polymorphic || derived->attr.abstract
2696 : 8697 : || !derived->attr.recursive)
2697 : 9487 : c->initializer = gfc_get_null_expr (NULL);
2698 : : else
2699 : : {
2700 : : /* Set up namespace. */
2701 : 222 : gfc_namespace *sub_ns = gfc_get_namespace (ns, 0);
2702 : :
2703 : 222 : sub_ns->sibling = ns->contained;
2704 : 222 : ns->contained = sub_ns;
2705 : 222 : sub_ns->resolved = 1;
2706 : : /* Set up procedure symbol. */
2707 : 222 : free (name);
2708 : 222 : name = xasprintf ("__deallocate_%s", tname);
2709 : 222 : gfc_get_symbol (name, sub_ns, &dealloc);
2710 : 222 : sub_ns->proc_name = dealloc;
2711 : 222 : dealloc->attr.flavor = FL_PROCEDURE;
2712 : 222 : dealloc->attr.subroutine = 1;
2713 : 222 : dealloc->attr.pure = 1;
2714 : 222 : dealloc->attr.artificial = 1;
2715 : 222 : dealloc->attr.if_source = IFSRC_DECL;
2716 : :
2717 : 222 : if (ns->proc_name->attr.flavor == FL_MODULE)
2718 : 159 : dealloc->module = ns->proc_name->name;
2719 : 222 : gfc_set_sym_referenced (dealloc);
2720 : : /* Set up formal argument. */
2721 : 222 : gfc_get_symbol ("arg", sub_ns, &arg);
2722 : 222 : arg->ts.type = BT_DERIVED;
2723 : 222 : arg->ts.u.derived = derived;
2724 : 222 : arg->attr.flavor = FL_VARIABLE;
2725 : 222 : arg->attr.dummy = 1;
2726 : 222 : arg->attr.artificial = 1;
2727 : 222 : arg->attr.intent = INTENT_INOUT;
2728 : 222 : arg->attr.dimension = 1;
2729 : 222 : arg->attr.allocatable = 1;
2730 : 222 : arg->as = gfc_get_array_spec();
2731 : 222 : arg->as->type = AS_ASSUMED_SHAPE;
2732 : 222 : arg->as->rank = 1;
2733 : 222 : arg->as->lower[0] = gfc_get_int_expr (gfc_default_integer_kind,
2734 : : NULL, 1);
2735 : 222 : gfc_set_sym_referenced (arg);
2736 : 222 : dealloc->formal = gfc_get_formal_arglist ();
2737 : 222 : dealloc->formal->sym = arg;
2738 : : /* Set up code. */
2739 : 222 : sub_ns->code = gfc_get_code (EXEC_DEALLOCATE);
2740 : 222 : sub_ns->code->ext.alloc.list = gfc_get_alloc ();
2741 : 222 : sub_ns->code->ext.alloc.list->expr
2742 : 222 : = gfc_lval_expr_from_sym (arg);
2743 : : /* Set initializer. */
2744 : 222 : c->initializer = gfc_lval_expr_from_sym (dealloc);
2745 : 222 : c->ts.interface = dealloc;
2746 : : }
2747 : :
2748 : : /* Add procedure pointers for type-bound procedures. */
2749 : 9709 : if (!derived->attr.unlimited_polymorphic)
2750 : 9002 : add_procs_to_declared_vtab (derived, vtype);
2751 : : }
2752 : :
2753 : 0 : have_vtype:
2754 : 9713 : vtab->ts.u.derived = vtype;
2755 : 9713 : vtab->value = gfc_default_initializer (&vtab->ts);
2756 : : }
2757 : 73947 : free (name);
2758 : : }
2759 : :
2760 : 73947 : found_sym = vtab;
2761 : :
2762 : 73947 : cleanup:
2763 : : /* It is unexpected to have some symbols added at resolution or code
2764 : : generation time. We commit the changes in order to keep a clean state. */
2765 : 73947 : if (found_sym)
2766 : : {
2767 : 73947 : gfc_commit_symbol (vtab);
2768 : 73947 : if (vtype)
2769 : 9713 : gfc_commit_symbol (vtype);
2770 : 73947 : if (def_init)
2771 : 8697 : gfc_commit_symbol (def_init);
2772 : 73947 : if (copy)
2773 : 8697 : gfc_commit_symbol (copy);
2774 : 73947 : if (src)
2775 : 8697 : gfc_commit_symbol (src);
2776 : 73947 : if (dst)
2777 : 8697 : gfc_commit_symbol (dst);
2778 : 73947 : if (dealloc)
2779 : 222 : gfc_commit_symbol (dealloc);
2780 : 73947 : if (arg)
2781 : 222 : gfc_commit_symbol (arg);
2782 : : }
2783 : : else
2784 : 0 : gfc_undo_symbols ();
2785 : :
2786 : : return found_sym;
2787 : : }
2788 : :
2789 : :
2790 : : /* Check if a derived type is finalizable. That is the case if it
2791 : : (1) has a FINAL subroutine or
2792 : : (2) has a nonpointer nonallocatable component of finalizable type.
2793 : : If it is finalizable, return an expression containing the
2794 : : finalization wrapper. */
2795 : :
2796 : : bool
2797 : 90519 : gfc_is_finalizable (gfc_symbol *derived, gfc_expr **final_expr)
2798 : : {
2799 : 90519 : gfc_symbol *vtab;
2800 : 90519 : gfc_component *c;
2801 : :
2802 : : /* (1) Check for FINAL subroutines. */
2803 : 90519 : if (derived->f2k_derived && derived->f2k_derived->finalizers)
2804 : 5523 : goto yes;
2805 : :
2806 : : /* (2) Check for components of finalizable type. */
2807 : 216353 : for (c = derived->components; c; c = c->next)
2808 : 131834 : if (c->ts.type == BT_DERIVED
2809 : 19777 : && !c->attr.pointer && !c->attr.proc_pointer && !c->attr.allocatable
2810 : 138456 : && gfc_is_finalizable (c->ts.u.derived, NULL))
2811 : 477 : goto yes;
2812 : :
2813 : : return false;
2814 : :
2815 : 6000 : yes:
2816 : : /* Make sure vtab is generated. */
2817 : 6000 : vtab = gfc_find_derived_vtab (derived);
2818 : 6000 : if (final_expr)
2819 : : {
2820 : : /* Return finalizer expression. */
2821 : 722 : gfc_component *final;
2822 : 722 : final = vtab->ts.u.derived->components->next->next->next->next->next;
2823 : 722 : gcc_assert (strcmp (final->name, "_final") == 0);
2824 : 722 : gcc_assert (final->initializer
2825 : : && final->initializer->expr_type != EXPR_NULL);
2826 : 722 : *final_expr = final->initializer;
2827 : : }
2828 : : return true;
2829 : : }
2830 : :
2831 : :
2832 : : bool
2833 : 498144 : gfc_may_be_finalized (gfc_typespec ts)
2834 : : {
2835 : 498144 : return (ts.type == BT_CLASS || (ts.type == BT_DERIVED
2836 : 62065 : && ts.u.derived && gfc_is_finalizable (ts.u.derived, NULL)));
2837 : : }
2838 : :
2839 : :
2840 : : /* Find (or generate) the symbol for an intrinsic type's vtab. This is
2841 : : needed to support unlimited polymorphism. */
2842 : :
2843 : : static gfc_symbol *
2844 : 6177 : find_intrinsic_vtab (gfc_typespec *ts)
2845 : : {
2846 : 6177 : gfc_namespace *ns;
2847 : 6177 : gfc_symbol *vtab = NULL, *vtype = NULL, *found_sym = NULL;
2848 : 6177 : gfc_symbol *copy = NULL, *src = NULL, *dst = NULL;
2849 : :
2850 : : /* Find the top-level namespace. */
2851 : 7962 : for (ns = gfc_current_ns; ns; ns = ns->parent)
2852 : 7962 : if (!ns->parent)
2853 : : break;
2854 : :
2855 : 6177 : if (ns)
2856 : : {
2857 : 6177 : char tname[GFC_MAX_SYMBOL_LEN+1];
2858 : 6177 : char *name;
2859 : :
2860 : : /* Encode all types as TYPENAME_KIND_ including especially character
2861 : : arrays, whose length is now consistently stored in the _len component
2862 : : of the class-variable. */
2863 : 6177 : sprintf (tname, "%s_%d_", gfc_basic_typename (ts->type), ts->kind);
2864 : 6177 : name = xasprintf ("__vtab_%s", tname);
2865 : :
2866 : : /* Look for the vtab symbol in the top-level namespace only. */
2867 : 6177 : gfc_find_symbol (name, ns, 0, &vtab);
2868 : :
2869 : 6177 : if (vtab == NULL)
2870 : : {
2871 : 844 : gfc_get_symbol (name, ns, &vtab);
2872 : 844 : vtab->ts.type = BT_DERIVED;
2873 : 844 : if (!gfc_add_flavor (&vtab->attr, FL_VARIABLE, NULL,
2874 : : &gfc_current_locus))
2875 : 0 : goto cleanup;
2876 : 844 : vtab->attr.target = 1;
2877 : 844 : vtab->attr.save = SAVE_IMPLICIT;
2878 : 844 : vtab->attr.vtab = 1;
2879 : 844 : vtab->attr.access = ACCESS_PUBLIC;
2880 : 844 : gfc_set_sym_referenced (vtab);
2881 : 844 : free (name);
2882 : 844 : name = xasprintf ("__vtype_%s", tname);
2883 : :
2884 : 844 : gfc_find_symbol (name, ns, 0, &vtype);
2885 : 844 : if (vtype == NULL)
2886 : : {
2887 : 844 : gfc_component *c;
2888 : 844 : int hash;
2889 : 844 : gfc_namespace *sub_ns;
2890 : 844 : gfc_namespace *contained;
2891 : 844 : gfc_expr *e;
2892 : 844 : size_t e_size;
2893 : :
2894 : 844 : gfc_get_symbol (name, ns, &vtype);
2895 : 844 : if (!gfc_add_flavor (&vtype->attr, FL_DERIVED, NULL,
2896 : : &gfc_current_locus))
2897 : 0 : goto cleanup;
2898 : 844 : vtype->attr.access = ACCESS_PUBLIC;
2899 : 844 : vtype->attr.vtype = 1;
2900 : 844 : gfc_set_sym_referenced (vtype);
2901 : :
2902 : : /* Add component '_hash'. */
2903 : 844 : if (!gfc_add_component (vtype, "_hash", &c))
2904 : 0 : goto cleanup;
2905 : 844 : c->ts.type = BT_INTEGER;
2906 : 844 : c->ts.kind = 4;
2907 : 844 : c->attr.access = ACCESS_PRIVATE;
2908 : 844 : hash = gfc_intrinsic_hash_value (ts);
2909 : 844 : c->initializer = gfc_get_int_expr (gfc_default_integer_kind,
2910 : : NULL, hash);
2911 : :
2912 : : /* Add component '_size'. */
2913 : 844 : if (!gfc_add_component (vtype, "_size", &c))
2914 : 0 : goto cleanup;
2915 : 844 : c->ts.type = BT_INTEGER;
2916 : 844 : c->ts.kind = gfc_size_kind;
2917 : 844 : c->attr.access = ACCESS_PRIVATE;
2918 : :
2919 : : /* Build a minimal expression to make use of
2920 : : target-memory.cc/gfc_element_size for 'size'. Special handling
2921 : : for character arrays, that are not constant sized: to support
2922 : : len (str) * kind, only the kind information is stored in the
2923 : : vtab. */
2924 : 844 : e = gfc_get_expr ();
2925 : 844 : e->ts = *ts;
2926 : 844 : e->expr_type = EXPR_VARIABLE;
2927 : 844 : if (ts->type == BT_CHARACTER)
2928 : 257 : e_size = ts->kind;
2929 : : else
2930 : 587 : gfc_element_size (e, &e_size);
2931 : 844 : c->initializer = gfc_get_int_expr (gfc_size_kind,
2932 : : NULL,
2933 : : e_size);
2934 : 844 : gfc_free_expr (e);
2935 : :
2936 : : /* Add component _extends. */
2937 : 844 : if (!gfc_add_component (vtype, "_extends", &c))
2938 : 0 : goto cleanup;
2939 : 844 : c->attr.pointer = 1;
2940 : 844 : c->attr.access = ACCESS_PRIVATE;
2941 : 844 : c->ts.type = BT_VOID;
2942 : 844 : c->initializer = gfc_get_null_expr (NULL);
2943 : :
2944 : : /* Add component _def_init. */
2945 : 844 : if (!gfc_add_component (vtype, "_def_init", &c))
2946 : 0 : goto cleanup;
2947 : 844 : c->attr.pointer = 1;
2948 : 844 : c->attr.access = ACCESS_PRIVATE;
2949 : 844 : c->ts.type = BT_VOID;
2950 : 844 : c->initializer = gfc_get_null_expr (NULL);
2951 : :
2952 : : /* Add component _copy. */
2953 : 844 : if (!gfc_add_component (vtype, "_copy", &c))
2954 : 0 : goto cleanup;
2955 : 844 : c->attr.proc_pointer = 1;
2956 : 844 : c->attr.access = ACCESS_PRIVATE;
2957 : 844 : c->attr.artificial = 1;
2958 : 844 : c->tb = XCNEW (gfc_typebound_proc);
2959 : 844 : c->tb->ppc = 1;
2960 : :
2961 : 844 : free (name);
2962 : 844 : if (ts->type != BT_CHARACTER)
2963 : 587 : name = xasprintf ("__copy_%s", tname);
2964 : : else
2965 : : {
2966 : : /* __copy is always the same for characters.
2967 : : Check to see if copy function already exists. */
2968 : 257 : name = xasprintf ("__copy_character_%d", ts->kind);
2969 : 257 : contained = ns->contained;
2970 : 1298 : for (; contained; contained = contained->sibling)
2971 : 1041 : if (contained->proc_name
2972 : 1041 : && strcmp (name, contained->proc_name->name) == 0)
2973 : : {
2974 : 0 : copy = contained->proc_name;
2975 : 0 : goto got_char_copy;
2976 : : }
2977 : : }
2978 : :
2979 : : /* Set up namespace. */
2980 : 844 : sub_ns = gfc_get_namespace (ns, 0);
2981 : 844 : sub_ns->sibling = ns->contained;
2982 : 844 : ns->contained = sub_ns;
2983 : 844 : sub_ns->resolved = 1;
2984 : : /* Set up procedure symbol. */
2985 : 844 : gfc_get_symbol (name, sub_ns, ©);
2986 : 844 : sub_ns->proc_name = copy;
2987 : 844 : copy->attr.flavor = FL_PROCEDURE;
2988 : 844 : copy->attr.subroutine = 1;
2989 : 844 : copy->attr.pure = 1;
2990 : 844 : copy->attr.if_source = IFSRC_DECL;
2991 : : /* This is elemental so that arrays are automatically
2992 : : treated correctly by the scalarizer. */
2993 : 844 : copy->attr.elemental = 1;
2994 : 844 : if (ns->proc_name && ns->proc_name->attr.flavor == FL_MODULE)
2995 : 191 : copy->module = ns->proc_name->name;
2996 : 844 : gfc_set_sym_referenced (copy);
2997 : : /* Set up formal arguments. */
2998 : 844 : gfc_get_symbol ("src", sub_ns, &src);
2999 : 844 : src->ts.type = ts->type;
3000 : 844 : src->ts.kind = ts->kind;
3001 : 844 : src->attr.flavor = FL_VARIABLE;
3002 : 844 : src->attr.dummy = 1;
3003 : 844 : src->attr.intent = INTENT_IN;
3004 : 844 : gfc_set_sym_referenced (src);
3005 : 844 : copy->formal = gfc_get_formal_arglist ();
3006 : 844 : copy->formal->sym = src;
3007 : 844 : gfc_get_symbol ("dst", sub_ns, &dst);
3008 : 844 : dst->ts.type = ts->type;
3009 : 844 : dst->ts.kind = ts->kind;
3010 : 844 : dst->attr.flavor = FL_VARIABLE;
3011 : 844 : dst->attr.dummy = 1;
3012 : 844 : dst->attr.intent = INTENT_INOUT;
3013 : 844 : gfc_set_sym_referenced (dst);
3014 : 844 : copy->formal->next = gfc_get_formal_arglist ();
3015 : 844 : copy->formal->next->sym = dst;
3016 : : /* Set up code. */
3017 : 844 : sub_ns->code = gfc_get_code (EXEC_INIT_ASSIGN);
3018 : 844 : sub_ns->code->expr1 = gfc_lval_expr_from_sym (dst);
3019 : 844 : sub_ns->code->expr2 = gfc_lval_expr_from_sym (src);
3020 : 844 : got_char_copy:
3021 : : /* Set initializer. */
3022 : 844 : c->initializer = gfc_lval_expr_from_sym (copy);
3023 : 844 : c->ts.interface = copy;
3024 : :
3025 : : /* Add component _final. */
3026 : 844 : if (!gfc_add_component (vtype, "_final", &c))
3027 : 0 : goto cleanup;
3028 : 844 : c->attr.proc_pointer = 1;
3029 : 844 : c->attr.access = ACCESS_PRIVATE;
3030 : 844 : c->attr.artificial = 1;
3031 : 844 : c->tb = XCNEW (gfc_typebound_proc);
3032 : 844 : c->tb->ppc = 1;
3033 : 844 : c->initializer = gfc_get_null_expr (NULL);
3034 : : }
3035 : 844 : vtab->ts.u.derived = vtype;
3036 : 844 : vtab->value = gfc_default_initializer (&vtab->ts);
3037 : : }
3038 : 6177 : free (name);
3039 : : }
3040 : :
3041 : 6177 : found_sym = vtab;
3042 : :
3043 : 6177 : cleanup:
3044 : : /* It is unexpected to have some symbols added at resolution or code
3045 : : generation time. We commit the changes in order to keep a clean state. */
3046 : 6177 : if (found_sym)
3047 : : {
3048 : 6177 : gfc_commit_symbol (vtab);
3049 : 6177 : if (vtype)
3050 : 844 : gfc_commit_symbol (vtype);
3051 : 6177 : if (copy)
3052 : 844 : gfc_commit_symbol (copy);
3053 : 6177 : if (src)
3054 : 844 : gfc_commit_symbol (src);
3055 : 6177 : if (dst)
3056 : 844 : gfc_commit_symbol (dst);
3057 : : }
3058 : : else
3059 : 0 : gfc_undo_symbols ();
3060 : :
3061 : 6177 : return found_sym;
3062 : : }
3063 : :
3064 : :
3065 : : /* Find (or generate) a vtab for an arbitrary type (derived or intrinsic). */
3066 : :
3067 : : gfc_symbol *
3068 : 18320 : gfc_find_vtab (gfc_typespec *ts)
3069 : : {
3070 : 18320 : switch (ts->type)
3071 : : {
3072 : : case BT_UNKNOWN:
3073 : : return NULL;
3074 : 7144 : case BT_DERIVED:
3075 : 7144 : return gfc_find_derived_vtab (ts->u.derived);
3076 : 4923 : case BT_CLASS:
3077 : 4923 : if (ts->u.derived->attr.is_class
3078 : 4919 : && ts->u.derived->components
3079 : 4919 : && ts->u.derived->components->ts.u.derived)
3080 : 4919 : return gfc_find_derived_vtab (ts->u.derived->components->ts.u.derived);
3081 : : else
3082 : : return NULL;
3083 : 6177 : default:
3084 : 6177 : return find_intrinsic_vtab (ts);
3085 : : }
3086 : : }
3087 : :
3088 : :
3089 : : /* General worker function to find either a type-bound procedure or a
3090 : : type-bound user operator. */
3091 : :
3092 : : static gfc_symtree*
3093 : 423715 : find_typebound_proc_uop (gfc_symbol* derived, bool* t,
3094 : : const char* name, bool noaccess, bool uop,
3095 : : locus* where)
3096 : : {
3097 : 423715 : gfc_symtree* res;
3098 : 423715 : gfc_symtree* root;
3099 : :
3100 : : /* Set default to failure. */
3101 : 423715 : if (t)
3102 : 404751 : *t = false;
3103 : :
3104 : 423715 : if (derived->f2k_derived)
3105 : : /* Set correct symbol-root. */
3106 : 321429 : root = (uop ? derived->f2k_derived->tb_uop_root
3107 : : : derived->f2k_derived->tb_sym_root);
3108 : : else
3109 : : return NULL;
3110 : :
3111 : : /* Try to find it in the current type's namespace. */
3112 : 321429 : res = gfc_find_symtree (root, name);
3113 : 321429 : if (res && res->n.tb && !res->n.tb->error)
3114 : : {
3115 : : /* We found one. */
3116 : 10201 : if (t)
3117 : 5779 : *t = true;
3118 : :
3119 : 10201 : if (!noaccess && derived->attr.use_assoc
3120 : 3180 : && res->n.tb->access == ACCESS_PRIVATE)
3121 : : {
3122 : 3 : if (where)
3123 : 2 : gfc_error ("%qs of %qs is PRIVATE at %L",
3124 : : name, derived->name, where);
3125 : 3 : if (t)
3126 : 3 : *t = false;
3127 : : }
3128 : :
3129 : 10201 : return res;
3130 : : }
3131 : :
3132 : : /* Otherwise, recurse on parent type if derived is an extension. */
3133 : 311228 : if (derived->attr.extension)
3134 : : {
3135 : 43425 : gfc_symbol* super_type;
3136 : 43425 : super_type = gfc_get_derived_super_type (derived);
3137 : 43425 : gcc_assert (super_type);
3138 : :
3139 : 43425 : return find_typebound_proc_uop (super_type, t, name,
3140 : 43425 : noaccess, uop, where);
3141 : : }
3142 : :
3143 : : /* Nothing found. */
3144 : : return NULL;
3145 : : }
3146 : :
3147 : :
3148 : : /* Find a type-bound procedure or user operator by name for a derived-type
3149 : : (looking recursively through the super-types). */
3150 : :
3151 : : gfc_symtree*
3152 : 380112 : gfc_find_typebound_proc (gfc_symbol* derived, bool* t,
3153 : : const char* name, bool noaccess, locus* where)
3154 : : {
3155 : 380112 : return find_typebound_proc_uop (derived, t, name, noaccess, false, where);
3156 : : }
3157 : :
3158 : : gfc_symtree*
3159 : 178 : gfc_find_typebound_user_op (gfc_symbol* derived, bool* t,
3160 : : const char* name, bool noaccess, locus* where)
3161 : : {
3162 : 178 : return find_typebound_proc_uop (derived, t, name, noaccess, true, where);
3163 : : }
3164 : :
3165 : :
3166 : : /* Find a type-bound intrinsic operator looking recursively through the
3167 : : super-type hierarchy. */
3168 : :
3169 : : gfc_typebound_proc*
3170 : 20618 : gfc_find_typebound_intrinsic_op (gfc_symbol* derived, bool* t,
3171 : : gfc_intrinsic_op op, bool noaccess,
3172 : : locus* where)
3173 : : {
3174 : 20618 : gfc_typebound_proc* res;
3175 : :
3176 : : /* Set default to failure. */
3177 : 20618 : if (t)
3178 : 20617 : *t = false;
3179 : :
3180 : : /* Try to find it in the current type's namespace. */
3181 : 20618 : if (derived->f2k_derived)
3182 : 16910 : res = derived->f2k_derived->tb_op[op];
3183 : : else
3184 : : res = NULL;
3185 : :
3186 : : /* Check access. */
3187 : 16910 : if (res && !res->error)
3188 : : {
3189 : : /* We found one. */
3190 : 861 : if (t)
3191 : 860 : *t = true;
3192 : :
3193 : 861 : if (!noaccess && derived->attr.use_assoc
3194 : 726 : && res->access == ACCESS_PRIVATE)
3195 : : {
3196 : 2 : if (where)
3197 : 0 : gfc_error ("%qs of %qs is PRIVATE at %L",
3198 : : gfc_op2string (op), derived->name, where);
3199 : 2 : if (t)
3200 : 2 : *t = false;
3201 : : }
3202 : :
3203 : 861 : return res;
3204 : : }
3205 : :
3206 : : /* Otherwise, recurse on parent type if derived is an extension. */
3207 : 19757 : if (derived->attr.extension)
3208 : : {
3209 : 798 : gfc_symbol* super_type;
3210 : 798 : super_type = gfc_get_derived_super_type (derived);
3211 : 798 : gcc_assert (super_type);
3212 : :
3213 : 798 : return gfc_find_typebound_intrinsic_op (super_type, t, op,
3214 : 798 : noaccess, where);
3215 : : }
3216 : :
3217 : : /* Nothing found. */
3218 : : return NULL;
3219 : : }
3220 : :
3221 : :
3222 : : /* Get a typebound-procedure symtree or create and insert it if not yet
3223 : : present. This is like a very simplified version of gfc_get_sym_tree for
3224 : : tbp-symtrees rather than regular ones. */
3225 : :
3226 : : gfc_symtree*
3227 : 8148 : gfc_get_tbp_symtree (gfc_symtree **root, const char *name)
3228 : : {
3229 : 8148 : gfc_symtree *result = gfc_find_symtree (*root, name);
3230 : 8148 : return result ? result : gfc_new_symtree (root, name);
3231 : : }
|
