1/* Header for code translation functions
2 Copyright (C) 2002-2017 Free Software Foundation, Inc.
3 Contributed by Paul Brook
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21#ifndef GFC_TRANS_H
22#define GFC_TRANS_H
23
24#include "predict.h" /* For enum br_predictor and PRED_*. */
25
26/* Mangled symbols take the form __module__name. */
27#define GFC_MAX_MANGLED_SYMBOL_LEN (GFC_MAX_SYMBOL_LEN*2+4)
28
29/* Struct for holding a block of statements. It should be treated as an
30 opaque entity and not modified directly. This allows us to change the
31 underlying representation of statement lists. */
32typedef struct
33{
34 tree head;
35 unsigned int has_scope:1;
36}
37stmtblock_t;
38
39/* a simplified expression */
40typedef struct gfc_se
41{
42 /* Code blocks to be executed before and after using the value. */
43 stmtblock_t pre;
44 stmtblock_t post;
45
46 /* the result of the expression */
47 tree expr;
48
49 /* The length of a character string value. */
50 tree string_length;
51
52 /* When expr is a reference to a class object, store its vptr access
53 here. */
54 tree class_vptr;
55
56 /* If set gfc_conv_variable will return an expression for the array
57 descriptor. When set, want_pointer should also be set.
58 If not set scalarizing variables will be substituted. */
59 unsigned descriptor_only:1;
60
61 /* When this is set gfc_conv_expr returns the address of a variable. Only
62 applies to EXPR_VARIABLE nodes.
63 Also used by gfc_conv_array_parameter. When set this indicates a pointer
64 to the descriptor should be returned, rather than the descriptor itself.
65 */
66 unsigned want_pointer:1;
67
68 /* An array function call returning without a temporary. Also used for array
69 pointer assignments. */
70 unsigned direct_byref:1;
71
72 /* If direct_byref is set, do work out the descriptor as in that case but
73 do still create a new descriptor variable instead of using an
74 existing one. This is useful for special pointer assignments like
75 rank remapping where we have to process the descriptor before
76 assigning to final one. */
77 unsigned byref_noassign:1;
78
79 /* Ignore absent optional arguments. Used for some intrinsics. */
80 unsigned ignore_optional:1;
81
82 /* When this is set the data and offset fields of the returned descriptor
83 are NULL. Used by intrinsic size. */
84 unsigned data_not_needed:1;
85
86 /* If set, gfc_conv_procedure_call does not put byref calls into se->pre. */
87 unsigned no_function_call:1;
88
89 /* If set, we will force the creation of a temporary. Useful to disable
90 non-copying procedure argument passing optimizations, when some function
91 args alias. */
92 unsigned force_tmp:1;
93
94 /* Unconditionally calculate offset for array segments and constant
95 arrays in gfc_conv_expr_descriptor. */
96 unsigned use_offset:1;
97
98 unsigned want_coarray:1;
99
100 /* Scalarization parameters. */
101 struct gfc_se *parent;
102 struct gfc_ss *ss;
103 struct gfc_loopinfo *loop;
104}
105gfc_se;
106
107
108/* Denotes different types of coarray.
109 Please keep in sync with libgfortran/caf/libcaf.h. */
110enum gfc_coarray_regtype
111{
112 GFC_CAF_COARRAY_STATIC,
113 GFC_CAF_COARRAY_ALLOC,
114 GFC_CAF_LOCK_STATIC,
115 GFC_CAF_LOCK_ALLOC,
116 GFC_CAF_CRITICAL,
117 GFC_CAF_EVENT_STATIC,
118 GFC_CAF_EVENT_ALLOC,
119 GFC_CAF_COARRAY_ALLOC_REGISTER_ONLY,
120 GFC_CAF_COARRAY_ALLOC_ALLOCATE_ONLY
121};
122
123
124/* Describes the action to take on _caf_deregister. Keep in sync with
125 gcc/fortran/trans.h. The negative values are not valid for the library and
126 are used by the drivers for building the correct call. */
127enum gfc_coarray_deregtype {
128 /* This is no coarray, i.e. build a call to a free (). */
129 GFC_CAF_COARRAY_NOCOARRAY = -2,
130 /* The driver is to analyze which _caf_deregister ()-call to generate. */
131 GFC_CAF_COARRAY_ANALYZE = -1,
132 GFC_CAF_COARRAY_DEREGISTER = 0,
133 GFC_CAF_COARRAY_DEALLOCATE_ONLY
134};
135
136
137/* Specify the type of ref handed to the caf communication functions.
138 Please keep in sync with libgfortran/caf/libcaf.h. */
139enum gfc_caf_ref_type_t {
140 GFC_CAF_REF_COMPONENT,
141 GFC_CAF_REF_ARRAY,
142 GFC_CAF_REF_STATIC_ARRAY
143};
144
145
146/* Give the reference type of an array ref.
147 Please keep in sync with libgfortran/caf/libcaf.h. */
148enum gfc_caf_array_ref_t {
149 GFC_CAF_ARR_REF_NONE = 0,
150 GFC_CAF_ARR_REF_VECTOR,
151 GFC_CAF_ARR_REF_FULL,
152 GFC_CAF_ARR_REF_RANGE,
153 GFC_CAF_ARR_REF_SINGLE,
154 GFC_CAF_ARR_REF_OPEN_END,
155 GFC_CAF_ARR_REF_OPEN_START
156};
157
158
159/* trans-array (structure_alloc_comps) caf_mode bits. */
160enum gfc_structure_caf_mode_t {
161 GFC_STRUCTURE_CAF_MODE_ENABLE_COARRAY = 1 << 0,
162 GFC_STRUCTURE_CAF_MODE_IN_COARRAY = 1 << 1,
163 GFC_STRUCTURE_CAF_MODE_DEALLOC_ONLY = 1 << 2
164};
165
166
167/* The array-specific scalarization information. The array members of
168 this struct are indexed by actual array index, and thus can be sparse. */
169
170typedef struct gfc_array_info
171{
172 mpz_t *shape;
173
174 /* The ref that holds information on this section. */
175 gfc_ref *ref;
176 /* The descriptor of this array. */
177 tree descriptor;
178 /* holds the pointer to the data array. */
179 tree data;
180 /* To move some of the array index calculation out of the innermost loop. */
181 tree offset;
182 tree saved_offset;
183 tree stride0;
184 /* Holds the SS for a subscript. Indexed by actual dimension. */
185 struct gfc_ss *subscript[GFC_MAX_DIMENSIONS];
186
187 /* stride and delta are used to access this inside a scalarization loop.
188 start is used in the calculation of these. Indexed by scalarizer
189 dimension. */
190 tree start[GFC_MAX_DIMENSIONS];
191 tree end[GFC_MAX_DIMENSIONS];
192 tree stride[GFC_MAX_DIMENSIONS];
193 tree delta[GFC_MAX_DIMENSIONS];
194}
195gfc_array_info;
196
197enum gfc_ss_type
198{
199 /* A scalar value. This will be evaluated before entering the
200 scalarization loop. */
201 GFC_SS_SCALAR,
202
203 /* Like GFC_SS_SCALAR it evaluates the expression outside the
204 loop. Is always evaluated as a reference to the temporary, unless
205 temporary evaluation can result in a NULL pointer dereferencing (case of
206 optional arguments). Used for elemental function arguments. */
207 GFC_SS_REFERENCE,
208
209 /* An array section. Scalarization indices will be substituted during
210 expression translation. */
211 GFC_SS_SECTION,
212
213 /* A non-elemental function call returning an array. The call is executed
214 before entering the scalarization loop, storing the result in a
215 temporary. This temporary is then used inside the scalarization loop.
216 Simple assignments, e.g. a(:) = fn(), are handled without a temporary
217 as a special case. */
218 GFC_SS_FUNCTION,
219
220 /* An array constructor. The current implementation is sub-optimal in
221 many cases. It allocated a temporary, assigns the values to it, then
222 uses this temporary inside the scalarization loop. */
223 GFC_SS_CONSTRUCTOR,
224
225 /* A vector subscript. The vector's descriptor is cached in the
226 "descriptor" field of the associated gfc_ss_info. */
227 GFC_SS_VECTOR,
228
229 /* A temporary array allocated by the scalarizer. Its rank can be less
230 than that of the assignment expression. */
231 GFC_SS_TEMP,
232
233 /* An intrinsic function call. Many intrinsic functions which map directly
234 to library calls are created as GFC_SS_FUNCTION nodes. */
235 GFC_SS_INTRINSIC,
236
237 /* A component of a derived type. */
238 GFC_SS_COMPONENT
239};
240
241
242typedef struct gfc_ss_info
243{
244 int refcount;
245 gfc_ss_type type;
246 gfc_expr *expr;
247 tree string_length;
248
249 union
250 {
251 /* If type is GFC_SS_SCALAR or GFC_SS_REFERENCE. */
252 struct
253 {
254 /* If the scalar is passed as actual argument to an (elemental) procedure,
255 this is the symbol of the corresponding dummy argument. */
256 gfc_symbol *dummy_arg;
257 tree value;
258 /* Tells that the scalar is a reference to a variable that might
259 be present on the lhs, so that we should evaluate the value
260 itself before the loop, not just the reference. */
261 unsigned needs_temporary:1;
262 }
263 scalar;
264
265 /* GFC_SS_TEMP. */
266 struct
267 {
268 tree type;
269 }
270 temp;
271
272 /* All other types. */
273 gfc_array_info array;
274 }
275 data;
276
277 /* This is used by assignments requiring temporaries. The bits specify which
278 loops the terms appear in. This will be 1 for the RHS expressions,
279 2 for the LHS expressions, and 3(=1|2) for the temporary. */
280 unsigned useflags:2;
281
282 /* Suppresses precalculation of scalars in WHERE assignments. */
283 unsigned where:1;
284
285 /* This set for an elemental function that contains expressions for
286 external arrays, thereby triggering creation of a temporary. */
287 unsigned array_outer_dependency:1;
288
289 /* Tells whether the SS is for an actual argument which can be a NULL
290 reference. In other words, the associated dummy argument is OPTIONAL.
291 Used to handle elemental procedures. */
292 bool can_be_null_ref;
293}
294gfc_ss_info;
295
296#define gfc_get_ss_info() XCNEW (gfc_ss_info)
297
298
299/* Scalarization State chain. Created by walking an expression tree before
300 creating the scalarization loops. Then passed as part of a gfc_se structure
301 to translate the expression inside the loop. Note that these chains are
302 terminated by gfc_ss_terminator, not NULL. A NULL pointer in a gfc_se
303 indicates to gfc_conv_* that this is a scalar expression.
304 SS structures can only belong to a single loopinfo. They must be added
305 otherwise they will not get freed. */
306
307typedef struct gfc_ss
308{
309 gfc_ss_info *info;
310
311 int dimen;
312 /* Translation from loop dimensions to actual array dimensions.
313 actual_dim = dim[loop_dim] */
314 int dim[GFC_MAX_DIMENSIONS];
315
316 /* All the SS in a loop and linked through loop_chain. The SS for an
317 expression are linked by the next pointer. */
318 struct gfc_ss *loop_chain;
319 struct gfc_ss *next;
320
321 /* Non-null if the ss is part of a nested loop. */
322 struct gfc_ss *parent;
323
324 /* If the evaluation of an expression requires a nested loop (for example
325 if the sum intrinsic is evaluated inline), this points to the nested
326 loop's gfc_ss. */
327 struct gfc_ss *nested_ss;
328
329 /* The loop this gfc_ss is in. */
330 struct gfc_loopinfo *loop;
331
332 unsigned is_alloc_lhs:1;
333}
334gfc_ss;
335#define gfc_get_ss() XCNEW (gfc_ss)
336
337/* The contents of this aren't actually used. A NULL SS chain indicates a
338 scalar expression, so this pointer is used to terminate SS chains. */
339extern gfc_ss * const gfc_ss_terminator;
340
341/* Holds information about an expression while it is being scalarized. */
342typedef struct gfc_loopinfo
343{
344 stmtblock_t pre;
345 stmtblock_t post;
346
347 int dimen;
348
349 /* All the SS involved with this loop. */
350 gfc_ss *ss;
351 /* The SS describing the temporary used in an assignment. */
352 gfc_ss *temp_ss;
353
354 /* Non-null if this loop is nested in another one. */
355 struct gfc_loopinfo *parent;
356
357 /* Chain of nested loops. */
358 struct gfc_loopinfo *nested, *next;
359
360 /* The scalarization loop index variables. */
361 tree loopvar[GFC_MAX_DIMENSIONS];
362
363 /* The bounds of the scalarization loops. */
364 tree from[GFC_MAX_DIMENSIONS];
365 tree to[GFC_MAX_DIMENSIONS];
366 gfc_ss *specloop[GFC_MAX_DIMENSIONS];
367
368 /* The code member contains the code for the body of the next outer loop. */
369 stmtblock_t code[GFC_MAX_DIMENSIONS];
370
371 /* Order in which the dimensions should be looped, innermost first. */
372 int order[GFC_MAX_DIMENSIONS];
373
374 /* Enum to control loop reversal. */
375 gfc_reverse reverse[GFC_MAX_DIMENSIONS];
376
377 /* The number of dimensions for which a temporary is used. */
378 int temp_dim;
379
380 /* If set we don't need the loop variables. */
381 unsigned array_parameter:1;
382}
383gfc_loopinfo;
384
385#define gfc_get_loopinfo() XCNEW (gfc_loopinfo)
386
387/* Information about a symbol that has been shadowed by a temporary. */
388typedef struct
389{
390 symbol_attribute attr;
391 tree decl;
392}
393gfc_saved_var;
394
395
396/* Store information about a block of code together with special
397 initialization and clean-up code. This can be used to incrementally add
398 init and cleanup, and in the end put everything together to a
399 try-finally expression. */
400typedef struct
401{
402 tree init;
403 tree cleanup;
404 tree code;
405}
406gfc_wrapped_block;
407
408/* Class API functions. */
409tree gfc_class_set_static_fields (tree, tree, tree);
410tree gfc_class_data_get (tree);
411tree gfc_class_vptr_get (tree);
412tree gfc_class_len_get (tree);
413tree gfc_class_len_or_zero_get (tree);
414gfc_expr * gfc_find_and_cut_at_last_class_ref (gfc_expr *);
415/* Get an accessor to the class' vtab's * field, when a class handle is
416 available. */
417tree gfc_class_vtab_hash_get (tree);
418tree gfc_class_vtab_size_get (tree);
419tree gfc_class_vtab_extends_get (tree);
420tree gfc_class_vtab_def_init_get (tree);
421tree gfc_class_vtab_copy_get (tree);
422tree gfc_class_vtab_final_get (tree);
423/* Get an accessor to the vtab's * field, when a vptr handle is present. */
424tree gfc_vtpr_hash_get (tree);
425tree gfc_vptr_size_get (tree);
426tree gfc_vptr_extends_get (tree);
427tree gfc_vptr_def_init_get (tree);
428tree gfc_vptr_copy_get (tree);
429tree gfc_vptr_final_get (tree);
430tree gfc_vptr_deallocate_get (tree);
431void gfc_reset_vptr (stmtblock_t *, gfc_expr *);
432void gfc_reset_len (stmtblock_t *, gfc_expr *);
433tree gfc_get_vptr_from_expr (tree);
434tree gfc_get_class_array_ref (tree, tree, tree);
435tree gfc_copy_class_to_class (tree, tree, tree, bool);
436bool gfc_add_finalizer_call (stmtblock_t *, gfc_expr *);
437bool gfc_add_comp_finalizer_call (stmtblock_t *, tree, gfc_component *, bool);
438
439void gfc_conv_derived_to_class (gfc_se *, gfc_expr *, gfc_typespec, tree, bool,
440 bool);
441void gfc_conv_class_to_class (gfc_se *, gfc_expr *, gfc_typespec, bool, bool,
442 bool, bool);
443
444/* Initialize an init/cleanup block. */
445void gfc_start_wrapped_block (gfc_wrapped_block* block, tree code);
446/* Add a pair of init/cleanup code to the block. Each one might be a
447 NULL_TREE if not required. */
448void gfc_add_init_cleanup (gfc_wrapped_block* block, tree init, tree cleanup);
449/* Finalize the block, that is, create a single expression encapsulating the
450 original code together with init and clean-up code. */
451tree gfc_finish_wrapped_block (gfc_wrapped_block* block);
452
453
454/* Advance the SS chain to the next term. */
455void gfc_advance_se_ss_chain (gfc_se *);
456
457/* Call this to initialize a gfc_se structure before use
458 first parameter is structure to initialize, second is
459 parent to get scalarization data from, or NULL. */
460void gfc_init_se (gfc_se *, gfc_se *);
461
462/* Create an artificial variable decl and add it to the current scope. */
463tree gfc_create_var (tree, const char *);
464/* Like above but doesn't add it to the current scope. */
465tree gfc_create_var_np (tree, const char *);
466
467/* Store the result of an expression in a temp variable so it can be used
468 repeatedly even if the original changes */
469void gfc_make_safe_expr (gfc_se * se);
470
471/* Makes sure se is suitable for passing as a function string parameter. */
472void gfc_conv_string_parameter (gfc_se * se);
473
474/* Compare two strings. */
475tree gfc_build_compare_string (tree, tree, tree, tree, int, enum tree_code);
476
477/* When using the gfc_conv_* make sure you understand what they do, i.e.
478 when a POST chain may be created, and what the returned expression may be
479 used for. Note that character strings have special handling. This
480 should not be a problem as most statements/operations only deal with
481 numeric/logical types. See the implementations in trans-expr.c
482 for details of the individual functions. */
483
484void gfc_conv_expr (gfc_se * se, gfc_expr * expr);
485void gfc_conv_expr_val (gfc_se * se, gfc_expr * expr);
486void gfc_conv_expr_lhs (gfc_se * se, gfc_expr * expr);
487void gfc_conv_expr_reference (gfc_se * se, gfc_expr *);
488void gfc_conv_expr_type (gfc_se * se, gfc_expr *, tree);
489
490
491/* trans-expr.c */
492tree gfc_conv_scalar_to_descriptor (gfc_se *, tree, symbol_attribute);
493tree gfc_get_ultimate_alloc_ptr_comps_caf_token (gfc_se *, gfc_expr *);
494void gfc_conv_scalar_char_value (gfc_symbol *sym, gfc_se *se, gfc_expr **expr);
495tree gfc_string_to_single_character (tree len, tree str, int kind);
496tree gfc_get_tree_for_caf_expr (gfc_expr *);
497void gfc_get_caf_token_offset (gfc_se*, tree *, tree *, tree, tree, gfc_expr *);
498tree gfc_caf_get_image_index (stmtblock_t *, gfc_expr *, tree);
499
500/* Find the decl containing the auxiliary variables for assigned variables. */
501void gfc_conv_label_variable (gfc_se * se, gfc_expr * expr);
502/* If the value is not constant, Create a temporary and copy the value. */
503tree gfc_evaluate_now_loc (location_t, tree, stmtblock_t *);
504tree gfc_evaluate_now (tree, stmtblock_t *);
505
506/* Find the appropriate variant of a math intrinsic. */
507tree gfc_builtin_decl_for_float_kind (enum built_in_function, int);
508
509tree size_of_string_in_bytes (int, tree);
510
511/* Intrinsic procedure handling. */
512tree gfc_conv_intrinsic_subroutine (gfc_code *);
513void gfc_conv_intrinsic_function (gfc_se *, gfc_expr *);
514bool gfc_conv_ieee_arithmetic_function (gfc_se *, gfc_expr *);
515tree gfc_save_fp_state (stmtblock_t *);
516void gfc_restore_fp_state (stmtblock_t *, tree);
517
518bool gfc_expr_is_variable (gfc_expr *);
519
520/* Does an intrinsic map directly to an external library call
521 This is true for array-returning intrinsics, unless
522 gfc_inline_intrinsic_function_p returns true. */
523int gfc_is_intrinsic_libcall (gfc_expr *);
524
525/* Used to call ordinary functions/subroutines
526 and procedure pointer components. */
527int gfc_conv_procedure_call (gfc_se *, gfc_symbol *, gfc_actual_arglist *,
528 gfc_expr *, vec<tree, va_gc> *);
529
530void gfc_conv_subref_array_arg (gfc_se *, gfc_expr *, int, sym_intent, bool);
531
532/* Generate code for a scalar assignment. */
533tree gfc_trans_scalar_assign (gfc_se *, gfc_se *, gfc_typespec, bool, bool,
534 bool c = false);
535
536/* Translate COMMON blocks. */
537void gfc_trans_common (gfc_namespace *);
538
539/* Translate a derived type constructor. */
540void gfc_conv_structure (gfc_se *, gfc_expr *, int);
541
542/* Return an expression which determines if a dummy parameter is present. */
543tree gfc_conv_expr_present (gfc_symbol *);
544/* Convert a missing, dummy argument into a null or zero. */
545void gfc_conv_missing_dummy (gfc_se *, gfc_expr *, gfc_typespec, int);
546
547/* Generate code to allocate a string temporary. */
548tree gfc_conv_string_tmp (gfc_se *, tree, tree);
549/* Get the string length variable belonging to an expression. */
550tree gfc_get_expr_charlen (gfc_expr *);
551/* Initialize a string length variable. */
552void gfc_conv_string_length (gfc_charlen *, gfc_expr *, stmtblock_t *);
553/* Ensure type sizes can be gimplified. */
554void gfc_trans_vla_type_sizes (gfc_symbol *, stmtblock_t *);
555
556/* Add an expression to the end of a block. */
557void gfc_add_expr_to_block (stmtblock_t *, tree);
558/* Add an expression to the beginning of a block. */
559void gfc_prepend_expr_to_block (stmtblock_t *, tree);
560/* Add a block to the end of a block. */
561void gfc_add_block_to_block (stmtblock_t *, stmtblock_t *);
562/* Add a MODIFY_EXPR to a block. */
563void gfc_add_modify_loc (location_t, stmtblock_t *, tree, tree);
564void gfc_add_modify (stmtblock_t *, tree, tree);
565
566/* Initialize a statement block. */
567void gfc_init_block (stmtblock_t *);
568/* Start a new statement block. Like gfc_init_block but also starts a new
569 variable scope. */
570void gfc_start_block (stmtblock_t *);
571/* Finish a statement block. Also closes the scope if the block was created
572 with gfc_start_block. */
573tree gfc_finish_block (stmtblock_t *);
574/* Merge the scope of a block with its parent. */
575void gfc_merge_block_scope (stmtblock_t * block);
576
577/* Return the backend label decl. */
578tree gfc_get_label_decl (gfc_st_label *);
579
580/* Return the decl for an external function. */
581tree gfc_get_extern_function_decl (gfc_symbol *);
582
583/* Return the decl for a function. */
584tree gfc_get_function_decl (gfc_symbol *);
585
586/* Build an ADDR_EXPR. */
587tree gfc_build_addr_expr (tree, tree);
588
589/* Build an ARRAY_REF. */
590tree gfc_build_array_ref (tree, tree, tree, tree vptr = NULL_TREE);
591
592/* Creates a label. Decl is artificial if label_id == NULL_TREE. */
593tree gfc_build_label_decl (tree);
594
595/* Return the decl used to hold the function return value.
596 Do not use if the function has an explicit result variable. */
597tree gfc_get_fake_result_decl (gfc_symbol *, int);
598
599/* Add a decl to the binding level for the current function. */
600void gfc_add_decl_to_function (tree);
601
602/* Make prototypes for runtime library functions. */
603void gfc_build_builtin_function_decls (void);
604
605/* Set the backend source location of a decl. */
606void gfc_set_decl_location (tree, locus *);
607
608/* Get a module symbol backend_decl if possible. */
609bool gfc_get_module_backend_decl (gfc_symbol *);
610
611/* Return the variable decl for a symbol. */
612tree gfc_get_symbol_decl (gfc_symbol *);
613
614/* Build a static initializer. */
615tree gfc_conv_initializer (gfc_expr *, gfc_typespec *, tree, bool, bool, bool);
616
617/* Assign a default initializer to a derived type. */
618void gfc_init_default_dt (gfc_symbol *, stmtblock_t *, bool);
619
620/* Substitute a temporary variable in place of the real one. */
621void gfc_shadow_sym (gfc_symbol *, tree, gfc_saved_var *);
622
623/* Restore the original variable. */
624void gfc_restore_sym (gfc_symbol *, gfc_saved_var *);
625
626/* Setting a decl assembler name, mangling it according to target rules
627 (like Windows @NN decorations). */
628void gfc_set_decl_assembler_name (tree, tree);
629
630/* Returns true if a variable of specified size should go on the stack. */
631int gfc_can_put_var_on_stack (tree);
632
633/* Set GFC_DECL_SCALAR_* on decl from sym if needed. */
634void gfc_finish_decl_attrs (tree, symbol_attribute *);
635
636/* Allocate the lang-specific part of a decl node. */
637void gfc_allocate_lang_decl (tree);
638
639/* Advance along a TREE_CHAIN. */
640tree gfc_advance_chain (tree, int);
641
642/* Create a decl for a function. */
643void gfc_create_function_decl (gfc_namespace *, bool);
644/* Generate the code for a function. */
645void gfc_generate_function_code (gfc_namespace *);
646/* Output a BLOCK DATA program unit. */
647void gfc_generate_block_data (gfc_namespace *);
648/* Output a decl for a module variable. */
649void gfc_generate_module_vars (gfc_namespace *);
650/* Get the appropriate return statement for a procedure. */
651tree gfc_generate_return (void);
652
653struct module_decl_hasher : ggc_ptr_hash<tree_node>
654{
655 typedef const char *compare_type;
656
657 static hashval_t hash (tree);
658 static bool equal (tree, const char *);
659};
660
661struct GTY((for_user)) module_htab_entry {
662 const char *name;
663 tree namespace_decl;
664 hash_table<module_decl_hasher> *GTY (()) decls;
665};
666
667struct module_htab_entry *gfc_find_module (const char *);
668void gfc_module_add_decl (struct module_htab_entry *, tree);
669
670/* Get and set the current location. */
671void gfc_save_backend_locus (locus *);
672void gfc_set_backend_locus (locus *);
673void gfc_restore_backend_locus (locus *);
674
675/* Handle static constructor functions. */
676extern GTY(()) tree gfc_static_ctors;
677void gfc_generate_constructors (void);
678
679/* Get the string length of an array constructor. */
680bool get_array_ctor_strlen (stmtblock_t *, gfc_constructor_base, tree *);
681
682/* Mark a condition as likely or unlikely. */
683tree gfc_likely (tree, enum br_predictor);
684tree gfc_unlikely (tree, enum br_predictor);
685
686/* Return the string length of a deferred character length component. */
687bool gfc_deferred_strlen (gfc_component *, tree *);
688
689/* Generate a runtime error call. */
690tree gfc_trans_runtime_error (bool, locus*, const char*, ...);
691
692/* Generate a runtime warning/error check. */
693void gfc_trans_runtime_check (bool, bool, tree, stmtblock_t *, locus *,
694 const char *, ...);
695
696/* Generate a runtime check for same string length. */
697void gfc_trans_same_strlen_check (const char*, locus*, tree, tree,
698 stmtblock_t*);
699
700/* Generate a call to free(). */
701tree gfc_call_free (tree);
702
703/* Allocate memory after performing a few checks. */
704tree gfc_call_malloc (stmtblock_t *, tree, tree);
705
706/* Build a memcpy call. */
707tree gfc_build_memcpy_call (tree, tree, tree);
708
709/* Register memory with the coarray library. */
710void gfc_allocate_using_caf_lib (stmtblock_t *, tree, tree, tree, tree, tree,
711 tree, gfc_coarray_regtype);
712
713/* Allocate memory for allocatable variables, with optional status variable. */
714void gfc_allocate_allocatable (stmtblock_t*, tree, tree, tree, tree,
715 tree, tree, tree, gfc_expr*, int);
716
717/* Allocate memory, with optional status variable. */
718void gfc_allocate_using_malloc (stmtblock_t *, tree, tree, tree);
719
720/* Generate code to deallocate an array. */
721tree gfc_deallocate_with_status (tree, tree, tree, tree, tree, bool,
722 gfc_expr *, int, tree a = NULL_TREE,
723 tree c = NULL_TREE);
724tree gfc_deallocate_scalar_with_status (tree, tree, tree, bool, gfc_expr*,
725 gfc_typespec, bool c = false);
726
727/* Generate code to call realloc(). */
728tree gfc_call_realloc (stmtblock_t *, tree, tree);
729
730/* Assign a derived type constructor to a variable. */
731tree gfc_trans_structure_assign (tree, gfc_expr *, bool, bool c = false);
732
733/* Generate code for an assignment, includes scalarization. */
734tree gfc_trans_assignment (gfc_expr *, gfc_expr *, bool, bool, bool p = false,
735 bool a = true);
736
737/* Generate code for a pointer assignment. */
738tree gfc_trans_pointer_assignment (gfc_expr *, gfc_expr *);
739
740/* Initialize function decls for library functions. */
741void gfc_build_intrinsic_lib_fndecls (void);
742/* Create function decls for IO library functions. */
743void gfc_build_io_library_fndecls (void);
744/* Build a function decl for a library function. */
745tree gfc_build_library_function_decl (tree, tree, int, ...);
746tree gfc_build_library_function_decl_with_spec (tree name, const char *spec,
747 tree rettype, int nargs, ...);
748
749/* Process the local variable decls of a block construct. */
750void gfc_process_block_locals (gfc_namespace*);
751
752/* Output initialization/clean-up code that was deferred. */
753void gfc_trans_deferred_vars (gfc_symbol*, gfc_wrapped_block *);
754
755/* In f95-lang.c. */
756tree pushdecl (tree);
757tree pushdecl_top_level (tree);
758void pushlevel (void);
759tree poplevel (int, int);
760tree getdecls (void);
761
762/* In trans-types.c. */
763struct array_descr_info;
764bool gfc_get_array_descr_info (const_tree, struct array_descr_info *);
765
766/* In trans-openmp.c */
767bool gfc_omp_privatize_by_reference (const_tree);
768enum omp_clause_default_kind gfc_omp_predetermined_sharing (tree);
769tree gfc_omp_report_decl (tree);
770tree gfc_omp_clause_default_ctor (tree, tree, tree);
771tree gfc_omp_clause_copy_ctor (tree, tree, tree);
772tree gfc_omp_clause_assign_op (tree, tree, tree);
773tree gfc_omp_clause_linear_ctor (tree, tree, tree, tree);
774tree gfc_omp_clause_dtor (tree, tree);
775void gfc_omp_finish_clause (tree, gimple_seq *);
776bool gfc_omp_scalar_p (tree);
777bool gfc_omp_disregard_value_expr (tree, bool);
778bool gfc_omp_private_debug_clause (tree, bool);
779bool gfc_omp_private_outer_ref (tree);
780struct gimplify_omp_ctx;
781void gfc_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *, tree);
782
783/* Runtime library function decls. */
784extern GTY(()) tree gfor_fndecl_pause_numeric;
785extern GTY(()) tree gfor_fndecl_pause_string;
786extern GTY(()) tree gfor_fndecl_stop_numeric;
787extern GTY(()) tree gfor_fndecl_stop_string;
788extern GTY(()) tree gfor_fndecl_error_stop_numeric;
789extern GTY(()) tree gfor_fndecl_error_stop_string;
790extern GTY(()) tree gfor_fndecl_runtime_error;
791extern GTY(()) tree gfor_fndecl_runtime_error_at;
792extern GTY(()) tree gfor_fndecl_runtime_warning_at;
793extern GTY(()) tree gfor_fndecl_os_error;
794extern GTY(()) tree gfor_fndecl_generate_error;
795extern GTY(()) tree gfor_fndecl_set_fpe;
796extern GTY(()) tree gfor_fndecl_set_options;
797extern GTY(()) tree gfor_fndecl_ttynam;
798extern GTY(()) tree gfor_fndecl_ctime;
799extern GTY(()) tree gfor_fndecl_fdate;
800extern GTY(()) tree gfor_fndecl_in_pack;
801extern GTY(()) tree gfor_fndecl_in_unpack;
802extern GTY(()) tree gfor_fndecl_associated;
803extern GTY(()) tree gfor_fndecl_system_clock4;
804extern GTY(()) tree gfor_fndecl_system_clock8;
805
806
807/* Coarray run-time library function decls. */
808extern GTY(()) tree gfor_fndecl_caf_init;
809extern GTY(()) tree gfor_fndecl_caf_finalize;
810extern GTY(()) tree gfor_fndecl_caf_this_image;
811extern GTY(()) tree gfor_fndecl_caf_num_images;
812extern GTY(()) tree gfor_fndecl_caf_register;
813extern GTY(()) tree gfor_fndecl_caf_deregister;
814extern GTY(()) tree gfor_fndecl_caf_get;
815extern GTY(()) tree gfor_fndecl_caf_send;
816extern GTY(()) tree gfor_fndecl_caf_sendget;
817extern GTY(()) tree gfor_fndecl_caf_get_by_ref;
818extern GTY(()) tree gfor_fndecl_caf_send_by_ref;
819extern GTY(()) tree gfor_fndecl_caf_sendget_by_ref;
820extern GTY(()) tree gfor_fndecl_caf_sync_all;
821extern GTY(()) tree gfor_fndecl_caf_sync_memory;
822extern GTY(()) tree gfor_fndecl_caf_sync_images;
823extern GTY(()) tree gfor_fndecl_caf_stop_numeric;
824extern GTY(()) tree gfor_fndecl_caf_stop_str;
825extern GTY(()) tree gfor_fndecl_caf_error_stop;
826extern GTY(()) tree gfor_fndecl_caf_error_stop_str;
827extern GTY(()) tree gfor_fndecl_caf_atomic_def;
828extern GTY(()) tree gfor_fndecl_caf_atomic_ref;
829extern GTY(()) tree gfor_fndecl_caf_atomic_cas;
830extern GTY(()) tree gfor_fndecl_caf_atomic_op;
831extern GTY(()) tree gfor_fndecl_caf_lock;
832extern GTY(()) tree gfor_fndecl_caf_unlock;
833extern GTY(()) tree gfor_fndecl_caf_event_post;
834extern GTY(()) tree gfor_fndecl_caf_event_wait;
835extern GTY(()) tree gfor_fndecl_caf_event_query;
836extern GTY(()) tree gfor_fndecl_caf_fail_image;
837extern GTY(()) tree gfor_fndecl_caf_failed_images;
838extern GTY(()) tree gfor_fndecl_caf_image_status;
839extern GTY(()) tree gfor_fndecl_caf_stopped_images;
840extern GTY(()) tree gfor_fndecl_co_broadcast;
841extern GTY(()) tree gfor_fndecl_co_max;
842extern GTY(()) tree gfor_fndecl_co_min;
843extern GTY(()) tree gfor_fndecl_co_reduce;
844extern GTY(()) tree gfor_fndecl_co_sum;
845extern GTY(()) tree gfor_fndecl_caf_is_present;
846
847/* Math functions. Many other math functions are handled in
848 trans-intrinsic.c. */
849
850typedef struct GTY(()) gfc_powdecl_list {
851 tree integer;
852 tree real;
853 tree cmplx;
854}
855gfc_powdecl_list;
856
857extern GTY(()) gfc_powdecl_list gfor_fndecl_math_powi[4][3];
858extern GTY(()) tree gfor_fndecl_math_ishftc4;
859extern GTY(()) tree gfor_fndecl_math_ishftc8;
860extern GTY(()) tree gfor_fndecl_math_ishftc16;
861
862/* BLAS functions. */
863extern GTY(()) tree gfor_fndecl_sgemm;
864extern GTY(()) tree gfor_fndecl_dgemm;
865extern GTY(()) tree gfor_fndecl_cgemm;
866extern GTY(()) tree gfor_fndecl_zgemm;
867
868/* String functions. */
869extern GTY(()) tree gfor_fndecl_compare_string;
870extern GTY(()) tree gfor_fndecl_concat_string;
871extern GTY(()) tree gfor_fndecl_string_len_trim;
872extern GTY(()) tree gfor_fndecl_string_index;
873extern GTY(()) tree gfor_fndecl_string_scan;
874extern GTY(()) tree gfor_fndecl_string_verify;
875extern GTY(()) tree gfor_fndecl_string_trim;
876extern GTY(()) tree gfor_fndecl_string_minmax;
877extern GTY(()) tree gfor_fndecl_adjustl;
878extern GTY(()) tree gfor_fndecl_adjustr;
879extern GTY(()) tree gfor_fndecl_select_string;
880extern GTY(()) tree gfor_fndecl_compare_string_char4;
881extern GTY(()) tree gfor_fndecl_concat_string_char4;
882extern GTY(()) tree gfor_fndecl_string_len_trim_char4;
883extern GTY(()) tree gfor_fndecl_string_index_char4;
884extern GTY(()) tree gfor_fndecl_string_scan_char4;
885extern GTY(()) tree gfor_fndecl_string_verify_char4;
886extern GTY(()) tree gfor_fndecl_string_trim_char4;
887extern GTY(()) tree gfor_fndecl_string_minmax_char4;
888extern GTY(()) tree gfor_fndecl_adjustl_char4;
889extern GTY(()) tree gfor_fndecl_adjustr_char4;
890extern GTY(()) tree gfor_fndecl_select_string_char4;
891
892/* Conversion between character kinds. */
893extern GTY(()) tree gfor_fndecl_convert_char1_to_char4;
894extern GTY(()) tree gfor_fndecl_convert_char4_to_char1;
895
896/* Other misc. runtime library functions. */
897extern GTY(()) tree gfor_fndecl_size0;
898extern GTY(()) tree gfor_fndecl_size1;
899extern GTY(()) tree gfor_fndecl_iargc;
900
901/* Implemented in Fortran. */
902extern GTY(()) tree gfor_fndecl_sc_kind;
903extern GTY(()) tree gfor_fndecl_si_kind;
904extern GTY(()) tree gfor_fndecl_sr_kind;
905
906/* IEEE-related. */
907extern GTY(()) tree gfor_fndecl_ieee_procedure_entry;
908extern GTY(()) tree gfor_fndecl_ieee_procedure_exit;
909
910
911/* True if node is an integer constant. */
912#define INTEGER_CST_P(node) (TREE_CODE(node) == INTEGER_CST)
913
914/* gfortran-specific declaration information, the _CONT versions denote
915 arrays with CONTIGUOUS attribute. */
916
917enum gfc_array_kind
918{
919 GFC_ARRAY_UNKNOWN,
920 GFC_ARRAY_ASSUMED_SHAPE,
921 GFC_ARRAY_ASSUMED_SHAPE_CONT,
922 GFC_ARRAY_ASSUMED_RANK,
923 GFC_ARRAY_ASSUMED_RANK_CONT,
924 GFC_ARRAY_ALLOCATABLE,
925 GFC_ARRAY_POINTER,
926 GFC_ARRAY_POINTER_CONT
927};
928
929/* Array types only. */
930struct GTY(()) lang_type {
931 int rank, corank;
932 enum gfc_array_kind akind;
933 tree lbound[GFC_MAX_DIMENSIONS];
934 tree ubound[GFC_MAX_DIMENSIONS];
935 tree stride[GFC_MAX_DIMENSIONS];
936 tree size;
937 tree offset;
938 tree dtype;
939 tree dataptr_type;
940 tree span;
941 tree base_decl[2];
942 tree nonrestricted_type;
943 tree caf_token;
944 tree caf_offset;
945};
946
947struct GTY(()) lang_decl {
948 /* Dummy variables. */
949 tree saved_descriptor;
950 /* Assigned integer nodes. Stringlength is the IO format string's length.
951 Addr is the address of the string or the target label. Stringlength is
952 initialized to -2 and assigned to -1 when addr is assigned to the
953 address of target label. */
954 tree stringlen;
955 tree addr;
956 tree span;
957 /* For assumed-shape coarrays. */
958 tree token, caf_offset;
959 unsigned int scalar_allocatable : 1;
960 unsigned int scalar_pointer : 1;
961};
962
963
964#define GFC_DECL_ASSIGN_ADDR(node) DECL_LANG_SPECIFIC(node)->addr
965#define GFC_DECL_STRING_LEN(node) DECL_LANG_SPECIFIC(node)->stringlen
966#define GFC_DECL_SPAN(node) DECL_LANG_SPECIFIC(node)->span
967#define GFC_DECL_TOKEN(node) DECL_LANG_SPECIFIC(node)->token
968#define GFC_DECL_CAF_OFFSET(node) DECL_LANG_SPECIFIC(node)->caf_offset
969#define GFC_DECL_SAVED_DESCRIPTOR(node) \
970 (DECL_LANG_SPECIFIC(node)->saved_descriptor)
971#define GFC_DECL_SCALAR_ALLOCATABLE(node) \
972 (DECL_LANG_SPECIFIC (node)->scalar_allocatable)
973#define GFC_DECL_SCALAR_POINTER(node) \
974 (DECL_LANG_SPECIFIC (node)->scalar_pointer)
975#define GFC_DECL_GET_SCALAR_ALLOCATABLE(node) \
976 (DECL_LANG_SPECIFIC (node) ? GFC_DECL_SCALAR_ALLOCATABLE (node) : 0)
977#define GFC_DECL_GET_SCALAR_POINTER(node) \
978 (DECL_LANG_SPECIFIC (node) ? GFC_DECL_SCALAR_POINTER (node) : 0)
979#define GFC_DECL_PACKED_ARRAY(node) DECL_LANG_FLAG_0(node)
980#define GFC_DECL_PARTIAL_PACKED_ARRAY(node) DECL_LANG_FLAG_1(node)
981#define GFC_DECL_ASSIGN(node) DECL_LANG_FLAG_2(node)
982#define GFC_DECL_COMMON_OR_EQUIV(node) DECL_LANG_FLAG_3(node)
983#define GFC_DECL_CRAY_POINTEE(node) DECL_LANG_FLAG_4(node)
984#define GFC_DECL_RESULT(node) DECL_LANG_FLAG_5(node)
985#define GFC_DECL_PTR_ARRAY_P(node) DECL_LANG_FLAG_6(node)
986#define GFC_DECL_ASSOCIATE_VAR_P(node) DECL_LANG_FLAG_7(node)
987#define GFC_DECL_CLASS(node) DECL_LANG_FLAG_8(node)
988
989/* An array descriptor. */
990#define GFC_DESCRIPTOR_TYPE_P(node) TYPE_LANG_FLAG_1(node)
991/* An array without a descriptor. */
992#define GFC_ARRAY_TYPE_P(node) TYPE_LANG_FLAG_2(node)
993/* Fortran CLASS type. */
994#define GFC_CLASS_TYPE_P(node) TYPE_LANG_FLAG_4(node)
995/* The GFC_TYPE_ARRAY_* members are present in both descriptor and
996 descriptorless array types. */
997#define GFC_TYPE_ARRAY_LBOUND(node, dim) \
998 (TYPE_LANG_SPECIFIC(node)->lbound[dim])
999#define GFC_TYPE_ARRAY_UBOUND(node, dim) \
1000 (TYPE_LANG_SPECIFIC(node)->ubound[dim])
1001#define GFC_TYPE_ARRAY_STRIDE(node, dim) \
1002 (TYPE_LANG_SPECIFIC(node)->stride[dim])
1003#define GFC_TYPE_ARRAY_RANK(node) (TYPE_LANG_SPECIFIC(node)->rank)
1004#define GFC_TYPE_ARRAY_CORANK(node) (TYPE_LANG_SPECIFIC(node)->corank)
1005#define GFC_TYPE_ARRAY_CAF_TOKEN(node) (TYPE_LANG_SPECIFIC(node)->caf_token)
1006#define GFC_TYPE_ARRAY_CAF_OFFSET(node) (TYPE_LANG_SPECIFIC(node)->caf_offset)
1007#define GFC_TYPE_ARRAY_SIZE(node) (TYPE_LANG_SPECIFIC(node)->size)
1008#define GFC_TYPE_ARRAY_OFFSET(node) (TYPE_LANG_SPECIFIC(node)->offset)
1009#define GFC_TYPE_ARRAY_AKIND(node) (TYPE_LANG_SPECIFIC(node)->akind)
1010/* Code should use gfc_get_dtype instead of accessing this directly. It may
1011 not be known when the type is created. */
1012#define GFC_TYPE_ARRAY_DTYPE(node) (TYPE_LANG_SPECIFIC(node)->dtype)
1013#define GFC_TYPE_ARRAY_DATAPTR_TYPE(node) \
1014 (TYPE_LANG_SPECIFIC(node)->dataptr_type)
1015#define GFC_TYPE_ARRAY_SPAN(node) (TYPE_LANG_SPECIFIC(node)->span)
1016#define GFC_TYPE_ARRAY_BASE_DECL(node, internal) \
1017 (TYPE_LANG_SPECIFIC(node)->base_decl[(internal)])
1018
1019
1020/* Build an expression with void type. */
1021#define build1_v(code, arg) \
1022 fold_build1_loc (input_location, code, void_type_node, arg)
1023#define build2_v(code, arg1, arg2) \
1024 fold_build2_loc (input_location, code, void_type_node, arg1, arg2)
1025#define build3_v(code, arg1, arg2, arg3) \
1026 fold_build3_loc (input_location, code, void_type_node, arg1, arg2, arg3)
1027#define build4_v(code, arg1, arg2, arg3, arg4) \
1028 build4_loc (input_location, code, void_type_node, arg1, arg2, \
1029 arg3, arg4)
1030
1031/* This group of functions allows a caller to evaluate an expression from
1032 the callee's interface. It establishes a mapping between the interface's
1033 dummy arguments and the caller's actual arguments, then applies that
1034 mapping to a given gfc_expr.
1035
1036 You can initialize a mapping structure like so:
1037
1038 gfc_interface_mapping mapping;
1039 ...
1040 gfc_init_interface_mapping (&mapping);
1041
1042 You should then evaluate each actual argument into a temporary
1043 gfc_se structure, here called "se", and map the result to the
1044 dummy argument's symbol, here called "sym":
1045
1046 gfc_add_interface_mapping (&mapping, sym, &se);
1047
1048 After adding all mappings, you should call:
1049
1050 gfc_finish_interface_mapping (&mapping, pre, post);
1051
1052 where "pre" and "post" are statement blocks for initialization
1053 and finalization code respectively. You can then evaluate an
1054 interface expression "expr" as follows:
1055
1056 gfc_apply_interface_mapping (&mapping, se, expr);
1057
1058 Once you've evaluated all expressions, you should free
1059 the mapping structure with:
1060
1061 gfc_free_interface_mapping (&mapping); */
1062
1063
1064/* This structure represents a mapping from OLD to NEW, where OLD is a
1065 dummy argument symbol and NEW is a symbol that represents the value
1066 of an actual argument. Mappings are linked together using NEXT
1067 (in no particular order). */
1068typedef struct gfc_interface_sym_mapping
1069{
1070 struct gfc_interface_sym_mapping *next;
1071 gfc_symbol *old;
1072 gfc_symtree *new_sym;
1073 gfc_expr *expr;
1074}
1075gfc_interface_sym_mapping;
1076
1077
1078/* This structure is used by callers to evaluate an expression from
1079 a callee's interface. */
1080typedef struct gfc_interface_mapping
1081{
1082 /* Maps the interface's dummy arguments to the values that the caller
1083 is passing. The whole list is owned by this gfc_interface_mapping. */
1084 gfc_interface_sym_mapping *syms;
1085
1086 /* A list of gfc_charlens that were needed when creating copies of
1087 expressions. The whole list is owned by this gfc_interface_mapping. */
1088 gfc_charlen *charlens;
1089}
1090gfc_interface_mapping;
1091
1092void gfc_init_interface_mapping (gfc_interface_mapping *);
1093void gfc_free_interface_mapping (gfc_interface_mapping *);
1094void gfc_add_interface_mapping (gfc_interface_mapping *,
1095 gfc_symbol *, gfc_se *, gfc_expr *);
1096void gfc_finish_interface_mapping (gfc_interface_mapping *,
1097 stmtblock_t *, stmtblock_t *);
1098void gfc_apply_interface_mapping (gfc_interface_mapping *,
1099 gfc_se *, gfc_expr *);
1100
1101
1102/* Standard error messages used in all the trans-*.c files. */
1103extern const char gfc_msg_fault[];
1104extern const char gfc_msg_wrong_return[];
1105
1106#define OMPWS_WORKSHARE_FLAG 1 /* Set if in a workshare construct. */
1107#define OMPWS_CURR_SINGLEUNIT 2 /* Set if current gfc_code in workshare
1108 construct is not workshared. */
1109#define OMPWS_SCALARIZER_WS 4 /* Set if scalarizer should attempt
1110 to create parallel loops. */
1111#define OMPWS_SCALARIZER_BODY 8 /* Set if handling body of potential
1112 parallel loop. */
1113#define OMPWS_NOWAIT 16 /* Use NOWAIT on OMP_FOR. */
1114extern int ompws_flags;
1115
1116#endif /* GFC_TRANS_H */
1117