|
111
|
1 /* gfortran header file
|
|
131
|
2 Copyright (C) 2000-2018 Free Software Foundation, Inc.
|
|
111
|
3 Contributed by Andy Vaught
|
|
|
4
|
|
|
5 This file is part of GCC.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify it under
|
|
|
8 the terms of the GNU General Public License as published by the Free
|
|
|
9 Software Foundation; either version 3, or (at your option) any later
|
|
|
10 version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
15 for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GCC; see the file COPYING3. If not see
|
|
|
19 <http://www.gnu.org/licenses/>. */
|
|
|
20
|
|
|
21 #ifndef GCC_GFORTRAN_H
|
|
|
22 #define GCC_GFORTRAN_H
|
|
|
23
|
|
|
24 /* It's probably insane to have this large of a header file, but it
|
|
|
25 seemed like everything had to be recompiled anyway when a change
|
|
|
26 was made to a header file, and there were ordering issues with
|
|
|
27 multiple header files. Besides, Microsoft's winnt.h was 250k last
|
|
|
28 time I looked, so by comparison this is perfectly reasonable. */
|
|
|
29
|
|
|
30 #ifndef GCC_CORETYPES_H
|
|
|
31 #error "gfortran.h must be included after coretypes.h"
|
|
|
32 #endif
|
|
|
33
|
|
|
34 /* In order for the format checking to accept the Fortran front end
|
|
|
35 diagnostic framework extensions, you must include this file before
|
|
|
36 diagnostic-core.h, not after. We override the definition of GCC_DIAG_STYLE
|
|
|
37 in c-common.h. */
|
|
|
38 #undef GCC_DIAG_STYLE
|
|
|
39 #define GCC_DIAG_STYLE __gcc_gfc__
|
|
|
40 #if defined(GCC_DIAGNOSTIC_CORE_H)
|
|
|
41 #error \
|
|
|
42 In order for the format checking to accept the Fortran front end diagnostic \
|
|
|
43 framework extensions, you must include this file before diagnostic-core.h, \
|
|
|
44 not after.
|
|
|
45 #endif
|
|
|
46
|
|
|
47 /* Declarations common to the front-end and library are put in
|
|
|
48 libgfortran/libgfortran_frontend.h */
|
|
|
49 #include "libgfortran.h"
|
|
|
50
|
|
|
51
|
|
|
52 #include "intl.h"
|
|
|
53 #include "splay-tree.h"
|
|
|
54
|
|
|
55 /* Major control parameters. */
|
|
|
56
|
|
|
57 #define GFC_MAX_SYMBOL_LEN 63 /* Must be at least 63 for F2003. */
|
|
|
58 #define GFC_LETTERS 26 /* Number of letters in the alphabet. */
|
|
|
59
|
|
|
60 #define MAX_SUBRECORD_LENGTH 2147483639 /* 2**31-9 */
|
|
|
61
|
|
|
62
|
|
|
63 #define gfc_is_whitespace(c) ((c==' ') || (c=='\t') || (c=='\f'))
|
|
|
64
|
|
|
65 /* Macros to check for groups of structure-like types and flavors since
|
|
|
66 derived types, structures, maps, unions are often treated similarly. */
|
|
|
67 #define gfc_bt_struct(t) \
|
|
|
68 ((t) == BT_DERIVED || (t) == BT_UNION)
|
|
|
69 #define gfc_fl_struct(f) \
|
|
|
70 ((f) == FL_DERIVED || (f) == FL_UNION || (f) == FL_STRUCT)
|
|
|
71 #define case_bt_struct case BT_DERIVED: case BT_UNION
|
|
|
72 #define case_fl_struct case FL_DERIVED: case FL_UNION: case FL_STRUCT
|
|
|
73
|
|
|
74 /* Stringization. */
|
|
|
75 #define stringize(x) expand_macro(x)
|
|
|
76 #define expand_macro(x) # x
|
|
|
77
|
|
|
78 /* For the runtime library, a standard prefix is a requirement to
|
|
|
79 avoid cluttering the namespace with things nobody asked for. It's
|
|
|
80 ugly to look at and a pain to type when you add the prefix by hand,
|
|
|
81 so we hide it behind a macro. */
|
|
|
82 #define PREFIX(x) "_gfortran_" x
|
|
|
83 #define PREFIX_LEN 10
|
|
|
84
|
|
|
85 /* A prefix for internal variables, which are not user-visible. */
|
|
|
86 #if !defined (NO_DOT_IN_LABEL)
|
|
|
87 # define GFC_PREFIX(x) "_F." x
|
|
|
88 #elif !defined (NO_DOLLAR_IN_LABEL)
|
|
|
89 # define GFC_PREFIX(x) "_F$" x
|
|
|
90 #else
|
|
|
91 # define GFC_PREFIX(x) "_F_" x
|
|
|
92 #endif
|
|
|
93
|
|
|
94 #define BLANK_COMMON_NAME "__BLNK__"
|
|
|
95
|
|
|
96 /* Macro to initialize an mstring structure. */
|
|
|
97 #define minit(s, t) { s, NULL, t }
|
|
|
98
|
|
|
99 /* Structure for storing strings to be matched by gfc_match_string. */
|
|
|
100 typedef struct
|
|
|
101 {
|
|
|
102 const char *string;
|
|
|
103 const char *mp;
|
|
|
104 int tag;
|
|
|
105 }
|
|
|
106 mstring;
|
|
|
107
|
|
|
108
|
|
|
109
|
|
|
110 /*************************** Enums *****************************/
|
|
|
111
|
|
|
112 /* Used when matching and resolving data I/O transfer statements. */
|
|
|
113
|
|
|
114 enum io_kind
|
|
|
115 { M_READ, M_WRITE, M_PRINT, M_INQUIRE };
|
|
|
116
|
|
|
117
|
|
|
118 /* These are flags for identifying whether we are reading a character literal
|
|
|
119 between quotes or normal source code. */
|
|
|
120
|
|
|
121 enum gfc_instring
|
|
|
122 { NONSTRING = 0, INSTRING_WARN, INSTRING_NOWARN };
|
|
|
123
|
|
|
124 /* This is returned by gfc_notification_std to know if, given the flags
|
|
|
125 that were given (-std=, -pedantic) we should issue an error, a warning
|
|
|
126 or nothing. */
|
|
|
127
|
|
|
128 enum notification
|
|
|
129 { SILENT, WARNING, ERROR };
|
|
|
130
|
|
|
131 /* Matchers return one of these three values. The difference between
|
|
|
132 MATCH_NO and MATCH_ERROR is that MATCH_ERROR means that a match was
|
|
|
133 successful, but that something non-syntactic is wrong and an error
|
|
|
134 has already been issued. */
|
|
|
135
|
|
|
136 enum match
|
|
|
137 { MATCH_NO = 1, MATCH_YES, MATCH_ERROR };
|
|
|
138
|
|
|
139 /* Used for different Fortran source forms in places like scanner.c. */
|
|
|
140 enum gfc_source_form
|
|
|
141 { FORM_FREE, FORM_FIXED, FORM_UNKNOWN };
|
|
|
142
|
|
|
143 /* Expression node types. */
|
|
|
144 enum expr_t
|
|
|
145 { EXPR_OP = 1, EXPR_FUNCTION, EXPR_CONSTANT, EXPR_VARIABLE,
|
|
|
146 EXPR_SUBSTRING, EXPR_STRUCTURE, EXPR_ARRAY, EXPR_NULL, EXPR_COMPCALL, EXPR_PPC
|
|
|
147 };
|
|
|
148
|
|
|
149 /* Array types. */
|
|
|
150 enum array_type
|
|
|
151 { AS_EXPLICIT = 1, AS_ASSUMED_SHAPE, AS_DEFERRED,
|
|
|
152 AS_ASSUMED_SIZE, AS_IMPLIED_SHAPE, AS_ASSUMED_RANK,
|
|
|
153 AS_UNKNOWN
|
|
|
154 };
|
|
|
155
|
|
|
156 enum ar_type
|
|
|
157 { AR_FULL = 1, AR_ELEMENT, AR_SECTION, AR_UNKNOWN };
|
|
|
158
|
|
|
159 /* Statement label types. ST_LABEL_DO_TARGET is used for obsolescent warnings
|
|
|
160 related to shared DO terminations and DO targets which are neither END DO
|
|
|
161 nor CONTINUE; otherwise it is identical to ST_LABEL_TARGET. */
|
|
|
162 enum gfc_sl_type
|
|
|
163 { ST_LABEL_UNKNOWN = 1, ST_LABEL_TARGET, ST_LABEL_DO_TARGET,
|
|
|
164 ST_LABEL_BAD_TARGET, ST_LABEL_FORMAT
|
|
|
165 };
|
|
|
166
|
|
|
167 /* Intrinsic operators. */
|
|
|
168 enum gfc_intrinsic_op
|
|
|
169 { GFC_INTRINSIC_BEGIN = 0,
|
|
|
170 INTRINSIC_NONE = -1, INTRINSIC_UPLUS = GFC_INTRINSIC_BEGIN,
|
|
|
171 INTRINSIC_UMINUS, INTRINSIC_PLUS, INTRINSIC_MINUS, INTRINSIC_TIMES,
|
|
|
172 INTRINSIC_DIVIDE, INTRINSIC_POWER, INTRINSIC_CONCAT,
|
|
|
173 INTRINSIC_AND, INTRINSIC_OR, INTRINSIC_EQV, INTRINSIC_NEQV,
|
|
|
174 /* ==, /=, >, >=, <, <= */
|
|
|
175 INTRINSIC_EQ, INTRINSIC_NE, INTRINSIC_GT, INTRINSIC_GE,
|
|
|
176 INTRINSIC_LT, INTRINSIC_LE,
|
|
|
177 /* .EQ., .NE., .GT., .GE., .LT., .LE. (OS = Old-Style) */
|
|
|
178 INTRINSIC_EQ_OS, INTRINSIC_NE_OS, INTRINSIC_GT_OS, INTRINSIC_GE_OS,
|
|
|
179 INTRINSIC_LT_OS, INTRINSIC_LE_OS,
|
|
|
180 INTRINSIC_NOT, INTRINSIC_USER, INTRINSIC_ASSIGN, INTRINSIC_PARENTHESES,
|
|
|
181 GFC_INTRINSIC_END, /* Sentinel */
|
|
|
182 /* User defined derived type pseudo operators. These are set beyond the
|
|
|
183 sentinel so that they are excluded from module_read and module_write. */
|
|
|
184 INTRINSIC_FORMATTED, INTRINSIC_UNFORMATTED
|
|
|
185 };
|
|
|
186
|
|
|
187 /* This macro is the number of intrinsic operators that exist.
|
|
|
188 Assumptions are made about the numbering of the interface_op enums. */
|
|
|
189 #define GFC_INTRINSIC_OPS GFC_INTRINSIC_END
|
|
|
190
|
|
|
191 /* Arithmetic results. */
|
|
|
192 enum arith
|
|
|
193 { ARITH_OK = 1, ARITH_OVERFLOW, ARITH_UNDERFLOW, ARITH_NAN,
|
|
131
|
194 ARITH_DIV0, ARITH_INCOMMENSURATE, ARITH_ASYMMETRIC, ARITH_PROHIBIT,
|
|
|
195 ARITH_WRONGCONCAT
|
|
111
|
196 };
|
|
|
197
|
|
|
198 /* Statements. */
|
|
|
199 enum gfc_statement
|
|
|
200 {
|
|
|
201 ST_ARITHMETIC_IF, ST_ALLOCATE, ST_ATTR_DECL, ST_ASSOCIATE,
|
|
|
202 ST_BACKSPACE, ST_BLOCK, ST_BLOCK_DATA,
|
|
|
203 ST_CALL, ST_CASE, ST_CLOSE, ST_COMMON, ST_CONTINUE, ST_CONTAINS, ST_CYCLE,
|
|
|
204 ST_DATA, ST_DATA_DECL, ST_DEALLOCATE, ST_DO, ST_ELSE, ST_ELSEIF,
|
|
|
205 ST_ELSEWHERE, ST_END_ASSOCIATE, ST_END_BLOCK, ST_END_BLOCK_DATA,
|
|
|
206 ST_ENDDO, ST_IMPLIED_ENDDO, ST_END_FILE, ST_FINAL, ST_FLUSH, ST_END_FORALL,
|
|
|
207 ST_END_FUNCTION, ST_ENDIF, ST_END_INTERFACE, ST_END_MODULE, ST_END_SUBMODULE,
|
|
|
208 ST_END_PROGRAM, ST_END_SELECT, ST_END_SUBROUTINE, ST_END_WHERE, ST_END_TYPE,
|
|
|
209 ST_ENTRY, ST_EQUIVALENCE, ST_ERROR_STOP, ST_EXIT, ST_FORALL, ST_FORALL_BLOCK,
|
|
|
210 ST_FORMAT, ST_FUNCTION, ST_GOTO, ST_IF_BLOCK, ST_IMPLICIT, ST_IMPLICIT_NONE,
|
|
|
211 ST_IMPORT, ST_INQUIRE, ST_INTERFACE, ST_SYNC_ALL, ST_SYNC_MEMORY,
|
|
|
212 ST_SYNC_IMAGES, ST_PARAMETER, ST_MODULE, ST_SUBMODULE, ST_MODULE_PROC,
|
|
|
213 ST_NAMELIST, ST_NULLIFY, ST_OPEN, ST_PAUSE, ST_PRIVATE, ST_PROGRAM, ST_PUBLIC,
|
|
|
214 ST_READ, ST_RETURN, ST_REWIND, ST_STOP, ST_SUBROUTINE, ST_TYPE, ST_USE,
|
|
|
215 ST_WHERE_BLOCK, ST_WHERE, ST_WAIT, ST_WRITE, ST_ASSIGNMENT,
|
|
|
216 ST_POINTER_ASSIGNMENT, ST_SELECT_CASE, ST_SEQUENCE, ST_SIMPLE_IF,
|
|
|
217 ST_STATEMENT_FUNCTION, ST_DERIVED_DECL, ST_LABEL_ASSIGNMENT, ST_ENUM,
|
|
|
218 ST_ENUMERATOR, ST_END_ENUM, ST_SELECT_TYPE, ST_TYPE_IS, ST_CLASS_IS,
|
|
|
219 ST_STRUCTURE_DECL, ST_END_STRUCTURE,
|
|
|
220 ST_UNION, ST_END_UNION, ST_MAP, ST_END_MAP,
|
|
|
221 ST_OACC_PARALLEL_LOOP, ST_OACC_END_PARALLEL_LOOP, ST_OACC_PARALLEL,
|
|
|
222 ST_OACC_END_PARALLEL, ST_OACC_KERNELS, ST_OACC_END_KERNELS, ST_OACC_DATA,
|
|
|
223 ST_OACC_END_DATA, ST_OACC_HOST_DATA, ST_OACC_END_HOST_DATA, ST_OACC_LOOP,
|
|
|
224 ST_OACC_END_LOOP, ST_OACC_DECLARE, ST_OACC_UPDATE, ST_OACC_WAIT,
|
|
|
225 ST_OACC_CACHE, ST_OACC_KERNELS_LOOP, ST_OACC_END_KERNELS_LOOP,
|
|
|
226 ST_OACC_ENTER_DATA, ST_OACC_EXIT_DATA, ST_OACC_ROUTINE,
|
|
|
227 ST_OACC_ATOMIC, ST_OACC_END_ATOMIC,
|
|
|
228 ST_OMP_ATOMIC, ST_OMP_BARRIER, ST_OMP_CRITICAL, ST_OMP_END_ATOMIC,
|
|
|
229 ST_OMP_END_CRITICAL, ST_OMP_END_DO, ST_OMP_END_MASTER, ST_OMP_END_ORDERED,
|
|
|
230 ST_OMP_END_PARALLEL, ST_OMP_END_PARALLEL_DO, ST_OMP_END_PARALLEL_SECTIONS,
|
|
|
231 ST_OMP_END_PARALLEL_WORKSHARE, ST_OMP_END_SECTIONS, ST_OMP_END_SINGLE,
|
|
|
232 ST_OMP_END_WORKSHARE, ST_OMP_DO, ST_OMP_FLUSH, ST_OMP_MASTER, ST_OMP_ORDERED,
|
|
|
233 ST_OMP_PARALLEL, ST_OMP_PARALLEL_DO, ST_OMP_PARALLEL_SECTIONS,
|
|
|
234 ST_OMP_PARALLEL_WORKSHARE, ST_OMP_SECTIONS, ST_OMP_SECTION, ST_OMP_SINGLE,
|
|
|
235 ST_OMP_THREADPRIVATE, ST_OMP_WORKSHARE, ST_OMP_TASK, ST_OMP_END_TASK,
|
|
|
236 ST_OMP_TASKWAIT, ST_OMP_TASKYIELD, ST_OMP_CANCEL, ST_OMP_CANCELLATION_POINT,
|
|
|
237 ST_OMP_TASKGROUP, ST_OMP_END_TASKGROUP, ST_OMP_SIMD, ST_OMP_END_SIMD,
|
|
|
238 ST_OMP_DO_SIMD, ST_OMP_END_DO_SIMD, ST_OMP_PARALLEL_DO_SIMD,
|
|
|
239 ST_OMP_END_PARALLEL_DO_SIMD, ST_OMP_DECLARE_SIMD, ST_OMP_DECLARE_REDUCTION,
|
|
|
240 ST_OMP_TARGET, ST_OMP_END_TARGET, ST_OMP_TARGET_DATA, ST_OMP_END_TARGET_DATA,
|
|
|
241 ST_OMP_TARGET_UPDATE, ST_OMP_DECLARE_TARGET,
|
|
|
242 ST_OMP_TEAMS, ST_OMP_END_TEAMS, ST_OMP_DISTRIBUTE, ST_OMP_END_DISTRIBUTE,
|
|
|
243 ST_OMP_DISTRIBUTE_SIMD, ST_OMP_END_DISTRIBUTE_SIMD,
|
|
|
244 ST_OMP_DISTRIBUTE_PARALLEL_DO, ST_OMP_END_DISTRIBUTE_PARALLEL_DO,
|
|
|
245 ST_OMP_DISTRIBUTE_PARALLEL_DO_SIMD, ST_OMP_END_DISTRIBUTE_PARALLEL_DO_SIMD,
|
|
|
246 ST_OMP_TARGET_TEAMS, ST_OMP_END_TARGET_TEAMS, ST_OMP_TEAMS_DISTRIBUTE,
|
|
|
247 ST_OMP_END_TEAMS_DISTRIBUTE, ST_OMP_TEAMS_DISTRIBUTE_SIMD,
|
|
|
248 ST_OMP_END_TEAMS_DISTRIBUTE_SIMD, ST_OMP_TARGET_TEAMS_DISTRIBUTE,
|
|
|
249 ST_OMP_END_TARGET_TEAMS_DISTRIBUTE, ST_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD,
|
|
|
250 ST_OMP_END_TARGET_TEAMS_DISTRIBUTE_SIMD, ST_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO,
|
|
|
251 ST_OMP_END_TEAMS_DISTRIBUTE_PARALLEL_DO,
|
|
|
252 ST_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO,
|
|
|
253 ST_OMP_END_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO,
|
|
|
254 ST_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
|
|
|
255 ST_OMP_END_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
|
|
|
256 ST_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
|
|
|
257 ST_OMP_END_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
|
|
|
258 ST_OMP_TARGET_PARALLEL, ST_OMP_END_TARGET_PARALLEL,
|
|
|
259 ST_OMP_TARGET_PARALLEL_DO, ST_OMP_END_TARGET_PARALLEL_DO,
|
|
|
260 ST_OMP_TARGET_PARALLEL_DO_SIMD, ST_OMP_END_TARGET_PARALLEL_DO_SIMD,
|
|
|
261 ST_OMP_TARGET_ENTER_DATA, ST_OMP_TARGET_EXIT_DATA,
|
|
|
262 ST_OMP_TARGET_SIMD, ST_OMP_END_TARGET_SIMD,
|
|
|
263 ST_OMP_TASKLOOP, ST_OMP_END_TASKLOOP,
|
|
|
264 ST_OMP_TASKLOOP_SIMD, ST_OMP_END_TASKLOOP_SIMD, ST_OMP_ORDERED_DEPEND,
|
|
|
265 ST_PROCEDURE, ST_GENERIC, ST_CRITICAL, ST_END_CRITICAL,
|
|
|
266 ST_GET_FCN_CHARACTERISTICS, ST_LOCK, ST_UNLOCK, ST_EVENT_POST,
|
|
131
|
267 ST_EVENT_WAIT, ST_FAIL_IMAGE, ST_FORM_TEAM, ST_CHANGE_TEAM,
|
|
|
268 ST_END_TEAM, ST_SYNC_TEAM, ST_NONE
|
|
111
|
269 };
|
|
|
270
|
|
|
271 /* Types of interfaces that we can have. Assignment interfaces are
|
|
|
272 considered to be intrinsic operators. */
|
|
|
273 enum interface_type
|
|
|
274 {
|
|
|
275 INTERFACE_NAMELESS = 1, INTERFACE_GENERIC,
|
|
|
276 INTERFACE_INTRINSIC_OP, INTERFACE_USER_OP, INTERFACE_ABSTRACT,
|
|
|
277 INTERFACE_DTIO
|
|
|
278 };
|
|
|
279
|
|
|
280 /* Symbol flavors: these are all mutually exclusive.
|
|
|
281 12 elements = 4 bits. */
|
|
|
282 enum sym_flavor
|
|
|
283 {
|
|
|
284 FL_UNKNOWN = 0, FL_PROGRAM, FL_BLOCK_DATA, FL_MODULE, FL_VARIABLE,
|
|
|
285 FL_PARAMETER, FL_LABEL, FL_PROCEDURE, FL_DERIVED, FL_NAMELIST,
|
|
|
286 FL_UNION, FL_STRUCT, FL_VOID
|
|
|
287 };
|
|
|
288
|
|
|
289 /* Procedure types. 7 elements = 3 bits. */
|
|
|
290 enum procedure_type
|
|
|
291 { PROC_UNKNOWN, PROC_MODULE, PROC_INTERNAL, PROC_DUMMY,
|
|
|
292 PROC_INTRINSIC, PROC_ST_FUNCTION, PROC_EXTERNAL
|
|
|
293 };
|
|
|
294
|
|
131
|
295 /* Intent types. Note that these values are also used in another enum in
|
|
|
296 decl.c (match_attr_spec). */
|
|
111
|
297 enum sym_intent
|
|
|
298 { INTENT_UNKNOWN = 0, INTENT_IN, INTENT_OUT, INTENT_INOUT
|
|
|
299 };
|
|
|
300
|
|
|
301 /* Access types. */
|
|
|
302 enum gfc_access
|
|
|
303 { ACCESS_UNKNOWN = 0, ACCESS_PUBLIC, ACCESS_PRIVATE
|
|
|
304 };
|
|
|
305
|
|
|
306 /* Flags to keep track of where an interface came from.
|
|
|
307 3 elements = 2 bits. */
|
|
|
308 enum ifsrc
|
|
|
309 { IFSRC_UNKNOWN = 0, /* Interface unknown, only return type may be known. */
|
|
|
310 IFSRC_DECL, /* FUNCTION or SUBROUTINE declaration. */
|
|
|
311 IFSRC_IFBODY /* INTERFACE statement or PROCEDURE statement
|
|
|
312 with explicit interface. */
|
|
|
313 };
|
|
|
314
|
|
|
315 /* Whether a SAVE attribute was set explicitly or implicitly. */
|
|
|
316 enum save_state
|
|
|
317 { SAVE_NONE = 0, SAVE_EXPLICIT, SAVE_IMPLICIT
|
|
|
318 };
|
|
|
319
|
|
|
320 /* Strings for all symbol attributes. We use these for dumping the
|
|
|
321 parse tree, in error messages, and also when reading and writing
|
|
|
322 modules. In symbol.c. */
|
|
|
323 extern const mstring flavors[];
|
|
|
324 extern const mstring procedures[];
|
|
|
325 extern const mstring intents[];
|
|
|
326 extern const mstring access_types[];
|
|
|
327 extern const mstring ifsrc_types[];
|
|
|
328 extern const mstring save_status[];
|
|
|
329
|
|
|
330 /* Strings for DTIO procedure names. In symbol.c. */
|
|
|
331 extern const mstring dtio_procs[];
|
|
|
332
|
|
|
333 enum dtio_codes
|
|
|
334 { DTIO_RF = 0, DTIO_WF, DTIO_RUF, DTIO_WUF };
|
|
|
335
|
|
|
336 /* Enumeration of all the generic intrinsic functions. Used by the
|
|
|
337 backend for identification of a function. */
|
|
|
338
|
|
|
339 enum gfc_isym_id
|
|
|
340 {
|
|
|
341 /* GFC_ISYM_NONE is used for intrinsics which will never be seen by
|
|
|
342 the backend (e.g. KIND). */
|
|
|
343 GFC_ISYM_NONE = 0,
|
|
|
344 GFC_ISYM_ABORT,
|
|
|
345 GFC_ISYM_ABS,
|
|
|
346 GFC_ISYM_ACCESS,
|
|
|
347 GFC_ISYM_ACHAR,
|
|
|
348 GFC_ISYM_ACOS,
|
|
|
349 GFC_ISYM_ACOSH,
|
|
|
350 GFC_ISYM_ADJUSTL,
|
|
|
351 GFC_ISYM_ADJUSTR,
|
|
|
352 GFC_ISYM_AIMAG,
|
|
|
353 GFC_ISYM_AINT,
|
|
|
354 GFC_ISYM_ALARM,
|
|
|
355 GFC_ISYM_ALL,
|
|
|
356 GFC_ISYM_ALLOCATED,
|
|
|
357 GFC_ISYM_AND,
|
|
|
358 GFC_ISYM_ANINT,
|
|
|
359 GFC_ISYM_ANY,
|
|
|
360 GFC_ISYM_ASIN,
|
|
|
361 GFC_ISYM_ASINH,
|
|
|
362 GFC_ISYM_ASSOCIATED,
|
|
|
363 GFC_ISYM_ATAN,
|
|
|
364 GFC_ISYM_ATAN2,
|
|
|
365 GFC_ISYM_ATANH,
|
|
|
366 GFC_ISYM_ATOMIC_ADD,
|
|
|
367 GFC_ISYM_ATOMIC_AND,
|
|
|
368 GFC_ISYM_ATOMIC_CAS,
|
|
|
369 GFC_ISYM_ATOMIC_DEF,
|
|
|
370 GFC_ISYM_ATOMIC_FETCH_ADD,
|
|
|
371 GFC_ISYM_ATOMIC_FETCH_AND,
|
|
|
372 GFC_ISYM_ATOMIC_FETCH_OR,
|
|
|
373 GFC_ISYM_ATOMIC_FETCH_XOR,
|
|
|
374 GFC_ISYM_ATOMIC_OR,
|
|
|
375 GFC_ISYM_ATOMIC_REF,
|
|
|
376 GFC_ISYM_ATOMIC_XOR,
|
|
|
377 GFC_ISYM_BGE,
|
|
|
378 GFC_ISYM_BGT,
|
|
|
379 GFC_ISYM_BIT_SIZE,
|
|
|
380 GFC_ISYM_BLE,
|
|
|
381 GFC_ISYM_BLT,
|
|
|
382 GFC_ISYM_BTEST,
|
|
|
383 GFC_ISYM_CAF_GET,
|
|
|
384 GFC_ISYM_CAF_SEND,
|
|
|
385 GFC_ISYM_CEILING,
|
|
|
386 GFC_ISYM_CHAR,
|
|
|
387 GFC_ISYM_CHDIR,
|
|
|
388 GFC_ISYM_CHMOD,
|
|
|
389 GFC_ISYM_CMPLX,
|
|
|
390 GFC_ISYM_CO_BROADCAST,
|
|
|
391 GFC_ISYM_CO_MAX,
|
|
|
392 GFC_ISYM_CO_MIN,
|
|
|
393 GFC_ISYM_CO_REDUCE,
|
|
|
394 GFC_ISYM_CO_SUM,
|
|
|
395 GFC_ISYM_COMMAND_ARGUMENT_COUNT,
|
|
|
396 GFC_ISYM_COMPILER_OPTIONS,
|
|
|
397 GFC_ISYM_COMPILER_VERSION,
|
|
|
398 GFC_ISYM_COMPLEX,
|
|
|
399 GFC_ISYM_CONJG,
|
|
|
400 GFC_ISYM_CONVERSION,
|
|
|
401 GFC_ISYM_COS,
|
|
|
402 GFC_ISYM_COSH,
|
|
|
403 GFC_ISYM_COTAN,
|
|
|
404 GFC_ISYM_COUNT,
|
|
|
405 GFC_ISYM_CPU_TIME,
|
|
|
406 GFC_ISYM_CSHIFT,
|
|
|
407 GFC_ISYM_CTIME,
|
|
|
408 GFC_ISYM_C_ASSOCIATED,
|
|
|
409 GFC_ISYM_C_F_POINTER,
|
|
|
410 GFC_ISYM_C_F_PROCPOINTER,
|
|
|
411 GFC_ISYM_C_FUNLOC,
|
|
|
412 GFC_ISYM_C_LOC,
|
|
|
413 GFC_ISYM_C_SIZEOF,
|
|
|
414 GFC_ISYM_DATE_AND_TIME,
|
|
|
415 GFC_ISYM_DBLE,
|
|
|
416 GFC_ISYM_DIGITS,
|
|
|
417 GFC_ISYM_DIM,
|
|
|
418 GFC_ISYM_DOT_PRODUCT,
|
|
|
419 GFC_ISYM_DPROD,
|
|
|
420 GFC_ISYM_DSHIFTL,
|
|
|
421 GFC_ISYM_DSHIFTR,
|
|
|
422 GFC_ISYM_DTIME,
|
|
|
423 GFC_ISYM_EOSHIFT,
|
|
|
424 GFC_ISYM_EPSILON,
|
|
|
425 GFC_ISYM_ERF,
|
|
|
426 GFC_ISYM_ERFC,
|
|
|
427 GFC_ISYM_ERFC_SCALED,
|
|
|
428 GFC_ISYM_ETIME,
|
|
|
429 GFC_ISYM_EVENT_QUERY,
|
|
|
430 GFC_ISYM_EXECUTE_COMMAND_LINE,
|
|
|
431 GFC_ISYM_EXIT,
|
|
|
432 GFC_ISYM_EXP,
|
|
|
433 GFC_ISYM_EXPONENT,
|
|
|
434 GFC_ISYM_EXTENDS_TYPE_OF,
|
|
|
435 GFC_ISYM_FAILED_IMAGES,
|
|
|
436 GFC_ISYM_FDATE,
|
|
|
437 GFC_ISYM_FE_RUNTIME_ERROR,
|
|
|
438 GFC_ISYM_FGET,
|
|
|
439 GFC_ISYM_FGETC,
|
|
|
440 GFC_ISYM_FLOOR,
|
|
|
441 GFC_ISYM_FLUSH,
|
|
|
442 GFC_ISYM_FNUM,
|
|
|
443 GFC_ISYM_FPUT,
|
|
|
444 GFC_ISYM_FPUTC,
|
|
|
445 GFC_ISYM_FRACTION,
|
|
|
446 GFC_ISYM_FREE,
|
|
|
447 GFC_ISYM_FSEEK,
|
|
|
448 GFC_ISYM_FSTAT,
|
|
|
449 GFC_ISYM_FTELL,
|
|
|
450 GFC_ISYM_TGAMMA,
|
|
|
451 GFC_ISYM_GERROR,
|
|
|
452 GFC_ISYM_GETARG,
|
|
|
453 GFC_ISYM_GET_COMMAND,
|
|
|
454 GFC_ISYM_GET_COMMAND_ARGUMENT,
|
|
|
455 GFC_ISYM_GETCWD,
|
|
|
456 GFC_ISYM_GETENV,
|
|
|
457 GFC_ISYM_GET_ENVIRONMENT_VARIABLE,
|
|
|
458 GFC_ISYM_GETGID,
|
|
|
459 GFC_ISYM_GETLOG,
|
|
|
460 GFC_ISYM_GETPID,
|
|
131
|
461 GFC_ISYM_GET_TEAM,
|
|
111
|
462 GFC_ISYM_GETUID,
|
|
|
463 GFC_ISYM_GMTIME,
|
|
|
464 GFC_ISYM_HOSTNM,
|
|
|
465 GFC_ISYM_HUGE,
|
|
|
466 GFC_ISYM_HYPOT,
|
|
|
467 GFC_ISYM_IACHAR,
|
|
|
468 GFC_ISYM_IALL,
|
|
|
469 GFC_ISYM_IAND,
|
|
|
470 GFC_ISYM_IANY,
|
|
|
471 GFC_ISYM_IARGC,
|
|
|
472 GFC_ISYM_IBCLR,
|
|
|
473 GFC_ISYM_IBITS,
|
|
|
474 GFC_ISYM_IBSET,
|
|
|
475 GFC_ISYM_ICHAR,
|
|
|
476 GFC_ISYM_IDATE,
|
|
|
477 GFC_ISYM_IEOR,
|
|
|
478 GFC_ISYM_IERRNO,
|
|
|
479 GFC_ISYM_IMAGE_INDEX,
|
|
|
480 GFC_ISYM_IMAGE_STATUS,
|
|
|
481 GFC_ISYM_INDEX,
|
|
|
482 GFC_ISYM_INT,
|
|
|
483 GFC_ISYM_INT2,
|
|
|
484 GFC_ISYM_INT8,
|
|
|
485 GFC_ISYM_IOR,
|
|
|
486 GFC_ISYM_IPARITY,
|
|
|
487 GFC_ISYM_IRAND,
|
|
|
488 GFC_ISYM_ISATTY,
|
|
|
489 GFC_ISYM_IS_IOSTAT_END,
|
|
|
490 GFC_ISYM_IS_IOSTAT_EOR,
|
|
|
491 GFC_ISYM_ISNAN,
|
|
|
492 GFC_ISYM_ISHFT,
|
|
|
493 GFC_ISYM_ISHFTC,
|
|
|
494 GFC_ISYM_ITIME,
|
|
|
495 GFC_ISYM_J0,
|
|
|
496 GFC_ISYM_J1,
|
|
|
497 GFC_ISYM_JN,
|
|
|
498 GFC_ISYM_JN2,
|
|
|
499 GFC_ISYM_KILL,
|
|
|
500 GFC_ISYM_KIND,
|
|
|
501 GFC_ISYM_LBOUND,
|
|
|
502 GFC_ISYM_LCOBOUND,
|
|
|
503 GFC_ISYM_LEADZ,
|
|
|
504 GFC_ISYM_LEN,
|
|
|
505 GFC_ISYM_LEN_TRIM,
|
|
|
506 GFC_ISYM_LGAMMA,
|
|
|
507 GFC_ISYM_LGE,
|
|
|
508 GFC_ISYM_LGT,
|
|
|
509 GFC_ISYM_LINK,
|
|
|
510 GFC_ISYM_LLE,
|
|
|
511 GFC_ISYM_LLT,
|
|
|
512 GFC_ISYM_LOC,
|
|
|
513 GFC_ISYM_LOG,
|
|
|
514 GFC_ISYM_LOG10,
|
|
|
515 GFC_ISYM_LOGICAL,
|
|
|
516 GFC_ISYM_LONG,
|
|
|
517 GFC_ISYM_LSHIFT,
|
|
|
518 GFC_ISYM_LSTAT,
|
|
|
519 GFC_ISYM_LTIME,
|
|
|
520 GFC_ISYM_MALLOC,
|
|
|
521 GFC_ISYM_MASKL,
|
|
|
522 GFC_ISYM_MASKR,
|
|
|
523 GFC_ISYM_MATMUL,
|
|
|
524 GFC_ISYM_MAX,
|
|
|
525 GFC_ISYM_MAXEXPONENT,
|
|
|
526 GFC_ISYM_MAXLOC,
|
|
|
527 GFC_ISYM_MAXVAL,
|
|
|
528 GFC_ISYM_MCLOCK,
|
|
|
529 GFC_ISYM_MCLOCK8,
|
|
|
530 GFC_ISYM_MERGE,
|
|
|
531 GFC_ISYM_MERGE_BITS,
|
|
|
532 GFC_ISYM_MIN,
|
|
|
533 GFC_ISYM_MINEXPONENT,
|
|
|
534 GFC_ISYM_MINLOC,
|
|
|
535 GFC_ISYM_MINVAL,
|
|
|
536 GFC_ISYM_MOD,
|
|
|
537 GFC_ISYM_MODULO,
|
|
|
538 GFC_ISYM_MOVE_ALLOC,
|
|
|
539 GFC_ISYM_MVBITS,
|
|
|
540 GFC_ISYM_NEAREST,
|
|
|
541 GFC_ISYM_NEW_LINE,
|
|
|
542 GFC_ISYM_NINT,
|
|
|
543 GFC_ISYM_NORM2,
|
|
|
544 GFC_ISYM_NOT,
|
|
|
545 GFC_ISYM_NULL,
|
|
|
546 GFC_ISYM_NUM_IMAGES,
|
|
|
547 GFC_ISYM_OR,
|
|
|
548 GFC_ISYM_PACK,
|
|
|
549 GFC_ISYM_PARITY,
|
|
|
550 GFC_ISYM_PERROR,
|
|
|
551 GFC_ISYM_POPCNT,
|
|
|
552 GFC_ISYM_POPPAR,
|
|
|
553 GFC_ISYM_PRECISION,
|
|
|
554 GFC_ISYM_PRESENT,
|
|
|
555 GFC_ISYM_PRODUCT,
|
|
|
556 GFC_ISYM_RADIX,
|
|
|
557 GFC_ISYM_RAND,
|
|
131
|
558 GFC_ISYM_RANDOM_INIT,
|
|
111
|
559 GFC_ISYM_RANDOM_NUMBER,
|
|
|
560 GFC_ISYM_RANDOM_SEED,
|
|
|
561 GFC_ISYM_RANGE,
|
|
|
562 GFC_ISYM_RANK,
|
|
|
563 GFC_ISYM_REAL,
|
|
|
564 GFC_ISYM_RENAME,
|
|
|
565 GFC_ISYM_REPEAT,
|
|
|
566 GFC_ISYM_RESHAPE,
|
|
|
567 GFC_ISYM_RRSPACING,
|
|
|
568 GFC_ISYM_RSHIFT,
|
|
|
569 GFC_ISYM_SAME_TYPE_AS,
|
|
|
570 GFC_ISYM_SC_KIND,
|
|
|
571 GFC_ISYM_SCALE,
|
|
|
572 GFC_ISYM_SCAN,
|
|
|
573 GFC_ISYM_SECNDS,
|
|
|
574 GFC_ISYM_SECOND,
|
|
|
575 GFC_ISYM_SET_EXPONENT,
|
|
|
576 GFC_ISYM_SHAPE,
|
|
|
577 GFC_ISYM_SHIFTA,
|
|
|
578 GFC_ISYM_SHIFTL,
|
|
|
579 GFC_ISYM_SHIFTR,
|
|
|
580 GFC_ISYM_BACKTRACE,
|
|
|
581 GFC_ISYM_SIGN,
|
|
|
582 GFC_ISYM_SIGNAL,
|
|
|
583 GFC_ISYM_SI_KIND,
|
|
|
584 GFC_ISYM_SIN,
|
|
|
585 GFC_ISYM_SINH,
|
|
|
586 GFC_ISYM_SIZE,
|
|
|
587 GFC_ISYM_SLEEP,
|
|
|
588 GFC_ISYM_SIZEOF,
|
|
|
589 GFC_ISYM_SPACING,
|
|
|
590 GFC_ISYM_SPREAD,
|
|
|
591 GFC_ISYM_SQRT,
|
|
|
592 GFC_ISYM_SRAND,
|
|
|
593 GFC_ISYM_SR_KIND,
|
|
|
594 GFC_ISYM_STAT,
|
|
|
595 GFC_ISYM_STOPPED_IMAGES,
|
|
|
596 GFC_ISYM_STORAGE_SIZE,
|
|
|
597 GFC_ISYM_STRIDE,
|
|
|
598 GFC_ISYM_SUM,
|
|
|
599 GFC_ISYM_SYMLINK,
|
|
|
600 GFC_ISYM_SYMLNK,
|
|
|
601 GFC_ISYM_SYSTEM,
|
|
|
602 GFC_ISYM_SYSTEM_CLOCK,
|
|
|
603 GFC_ISYM_TAN,
|
|
|
604 GFC_ISYM_TANH,
|
|
131
|
605 GFC_ISYM_TEAM_NUMBER,
|
|
111
|
606 GFC_ISYM_THIS_IMAGE,
|
|
|
607 GFC_ISYM_TIME,
|
|
|
608 GFC_ISYM_TIME8,
|
|
|
609 GFC_ISYM_TINY,
|
|
|
610 GFC_ISYM_TRAILZ,
|
|
|
611 GFC_ISYM_TRANSFER,
|
|
|
612 GFC_ISYM_TRANSPOSE,
|
|
|
613 GFC_ISYM_TRIM,
|
|
|
614 GFC_ISYM_TTYNAM,
|
|
|
615 GFC_ISYM_UBOUND,
|
|
|
616 GFC_ISYM_UCOBOUND,
|
|
|
617 GFC_ISYM_UMASK,
|
|
|
618 GFC_ISYM_UNLINK,
|
|
|
619 GFC_ISYM_UNPACK,
|
|
|
620 GFC_ISYM_VERIFY,
|
|
|
621 GFC_ISYM_XOR,
|
|
|
622 GFC_ISYM_Y0,
|
|
|
623 GFC_ISYM_Y1,
|
|
|
624 GFC_ISYM_YN,
|
|
|
625 GFC_ISYM_YN2
|
|
|
626 };
|
|
|
627
|
|
|
628 enum init_local_logical
|
|
|
629 {
|
|
|
630 GFC_INIT_LOGICAL_OFF = 0,
|
|
|
631 GFC_INIT_LOGICAL_FALSE,
|
|
|
632 GFC_INIT_LOGICAL_TRUE
|
|
|
633 };
|
|
|
634
|
|
|
635 enum init_local_character
|
|
|
636 {
|
|
|
637 GFC_INIT_CHARACTER_OFF = 0,
|
|
|
638 GFC_INIT_CHARACTER_ON
|
|
|
639 };
|
|
|
640
|
|
|
641 enum init_local_integer
|
|
|
642 {
|
|
|
643 GFC_INIT_INTEGER_OFF = 0,
|
|
|
644 GFC_INIT_INTEGER_ON
|
|
|
645 };
|
|
|
646
|
|
|
647 enum gfc_reverse
|
|
|
648 {
|
|
|
649 GFC_ENABLE_REVERSE,
|
|
|
650 GFC_FORWARD_SET,
|
|
|
651 GFC_REVERSE_SET,
|
|
|
652 GFC_INHIBIT_REVERSE
|
|
|
653 };
|
|
|
654
|
|
|
655 enum gfc_param_spec_type
|
|
|
656 {
|
|
|
657 SPEC_EXPLICIT,
|
|
|
658 SPEC_ASSUMED,
|
|
|
659 SPEC_DEFERRED
|
|
|
660 };
|
|
|
661
|
|
|
662 /************************* Structures *****************************/
|
|
|
663
|
|
|
664 /* Used for keeping things in balanced binary trees. */
|
|
|
665 #define BBT_HEADER(self) int priority; struct self *left, *right
|
|
|
666
|
|
|
667 #define NAMED_INTCST(a,b,c,d) a,
|
|
|
668 #define NAMED_KINDARRAY(a,b,c,d) a,
|
|
|
669 #define NAMED_FUNCTION(a,b,c,d) a,
|
|
|
670 #define NAMED_SUBROUTINE(a,b,c,d) a,
|
|
|
671 #define NAMED_DERIVED_TYPE(a,b,c,d) a,
|
|
|
672 enum iso_fortran_env_symbol
|
|
|
673 {
|
|
|
674 ISOFORTRANENV_INVALID = -1,
|
|
|
675 #include "iso-fortran-env.def"
|
|
|
676 ISOFORTRANENV_LAST, ISOFORTRANENV_NUMBER = ISOFORTRANENV_LAST
|
|
|
677 };
|
|
|
678 #undef NAMED_INTCST
|
|
|
679 #undef NAMED_KINDARRAY
|
|
|
680 #undef NAMED_FUNCTION
|
|
|
681 #undef NAMED_SUBROUTINE
|
|
|
682 #undef NAMED_DERIVED_TYPE
|
|
|
683
|
|
|
684 #define NAMED_INTCST(a,b,c,d) a,
|
|
|
685 #define NAMED_REALCST(a,b,c,d) a,
|
|
|
686 #define NAMED_CMPXCST(a,b,c,d) a,
|
|
|
687 #define NAMED_LOGCST(a,b,c) a,
|
|
|
688 #define NAMED_CHARKNDCST(a,b,c) a,
|
|
|
689 #define NAMED_CHARCST(a,b,c) a,
|
|
|
690 #define DERIVED_TYPE(a,b,c) a,
|
|
|
691 #define NAMED_FUNCTION(a,b,c,d) a,
|
|
|
692 #define NAMED_SUBROUTINE(a,b,c,d) a,
|
|
|
693 enum iso_c_binding_symbol
|
|
|
694 {
|
|
|
695 ISOCBINDING_INVALID = -1,
|
|
|
696 #include "iso-c-binding.def"
|
|
|
697 ISOCBINDING_LAST,
|
|
|
698 ISOCBINDING_NUMBER = ISOCBINDING_LAST
|
|
|
699 };
|
|
|
700 #undef NAMED_INTCST
|
|
|
701 #undef NAMED_REALCST
|
|
|
702 #undef NAMED_CMPXCST
|
|
|
703 #undef NAMED_LOGCST
|
|
|
704 #undef NAMED_CHARKNDCST
|
|
|
705 #undef NAMED_CHARCST
|
|
|
706 #undef DERIVED_TYPE
|
|
|
707 #undef NAMED_FUNCTION
|
|
|
708 #undef NAMED_SUBROUTINE
|
|
|
709
|
|
|
710 enum intmod_id
|
|
|
711 {
|
|
|
712 INTMOD_NONE = 0, INTMOD_ISO_FORTRAN_ENV, INTMOD_ISO_C_BINDING,
|
|
|
713 INTMOD_IEEE_FEATURES, INTMOD_IEEE_EXCEPTIONS, INTMOD_IEEE_ARITHMETIC
|
|
|
714 };
|
|
|
715
|
|
|
716 typedef struct
|
|
|
717 {
|
|
|
718 char name[GFC_MAX_SYMBOL_LEN + 1];
|
|
|
719 int value; /* Used for both integer and character values. */
|
|
|
720 bt f90_type;
|
|
|
721 }
|
|
|
722 CInteropKind_t;
|
|
|
723
|
|
|
724 /* Array of structs, where the structs represent the C interop kinds.
|
|
|
725 The list will be implemented based on a hash of the kind name since
|
|
|
726 these could be accessed multiple times.
|
|
|
727 Declared in trans-types.c as a global, since it's in that file
|
|
|
728 that the list is initialized. */
|
|
|
729 extern CInteropKind_t c_interop_kinds_table[];
|
|
|
730
|
|
|
731
|
|
|
732 /* Structure and list of supported extension attributes. */
|
|
|
733 typedef enum
|
|
|
734 {
|
|
|
735 EXT_ATTR_DLLIMPORT = 0,
|
|
|
736 EXT_ATTR_DLLEXPORT,
|
|
|
737 EXT_ATTR_STDCALL,
|
|
|
738 EXT_ATTR_CDECL,
|
|
|
739 EXT_ATTR_FASTCALL,
|
|
|
740 EXT_ATTR_NO_ARG_CHECK,
|
|
|
741 EXT_ATTR_LAST, EXT_ATTR_NUM = EXT_ATTR_LAST
|
|
|
742 }
|
|
|
743 ext_attr_id_t;
|
|
|
744
|
|
|
745 typedef struct
|
|
|
746 {
|
|
|
747 const char *name;
|
|
|
748 unsigned id;
|
|
|
749 const char *middle_end_name;
|
|
|
750 }
|
|
|
751 ext_attr_t;
|
|
|
752
|
|
|
753 extern const ext_attr_t ext_attr_list[];
|
|
|
754
|
|
|
755 /* Symbol attribute structure. */
|
|
|
756 typedef struct
|
|
|
757 {
|
|
|
758 /* Variable attributes. */
|
|
|
759 unsigned allocatable:1, dimension:1, codimension:1, external:1, intrinsic:1,
|
|
|
760 optional:1, pointer:1, target:1, value:1, volatile_:1, temporary:1,
|
|
|
761 dummy:1, result:1, assign:1, threadprivate:1, not_always_present:1,
|
|
|
762 implied_index:1, subref_array_pointer:1, proc_pointer:1, asynchronous:1,
|
|
|
763 contiguous:1, fe_temp: 1, automatic: 1;
|
|
|
764
|
|
|
765 /* For CLASS containers, the pointer attribute is sometimes set internally
|
|
|
766 even though it was not directly specified. In this case, keep the
|
|
|
767 "real" (original) value here. */
|
|
|
768 unsigned class_pointer:1;
|
|
|
769
|
|
|
770 ENUM_BITFIELD (save_state) save:2;
|
|
|
771
|
|
|
772 unsigned data:1, /* Symbol is named in a DATA statement. */
|
|
|
773 is_protected:1, /* Symbol has been marked as protected. */
|
|
|
774 use_assoc:1, /* Symbol has been use-associated. */
|
|
|
775 used_in_submodule:1, /* Symbol has been use-associated in a
|
|
|
776 submodule. Needed since these entities must
|
|
|
777 be set host associated to be compliant. */
|
|
|
778 use_only:1, /* Symbol has been use-associated, with ONLY. */
|
|
|
779 use_rename:1, /* Symbol has been use-associated and renamed. */
|
|
|
780 imported:1, /* Symbol has been associated by IMPORT. */
|
|
|
781 host_assoc:1; /* Symbol has been host associated. */
|
|
|
782
|
|
|
783 unsigned in_namelist:1, in_common:1, in_equivalence:1;
|
|
|
784 unsigned function:1, subroutine:1, procedure:1;
|
|
|
785 unsigned generic:1, generic_copy:1;
|
|
|
786 unsigned implicit_type:1; /* Type defined via implicit rules. */
|
|
|
787 unsigned untyped:1; /* No implicit type could be found. */
|
|
|
788
|
|
|
789 unsigned is_bind_c:1; /* say if is bound to C. */
|
|
|
790 unsigned extension:8; /* extension level of a derived type. */
|
|
|
791 unsigned is_class:1; /* is a CLASS container. */
|
|
|
792 unsigned class_ok:1; /* is a CLASS object with correct attributes. */
|
|
|
793 unsigned vtab:1; /* is a derived type vtab, pointed to by CLASS objects. */
|
|
|
794 unsigned vtype:1; /* is a derived type of a vtab. */
|
|
|
795
|
|
|
796 /* These flags are both in the typespec and attribute. The attribute
|
|
|
797 list is what gets read from/written to a module file. The typespec
|
|
|
798 is created from a decl being processed. */
|
|
|
799 unsigned is_c_interop:1; /* It's c interoperable. */
|
|
|
800 unsigned is_iso_c:1; /* Symbol is from iso_c_binding. */
|
|
|
801
|
|
|
802 /* Function/subroutine attributes */
|
|
|
803 unsigned sequence:1, elemental:1, pure:1, recursive:1;
|
|
|
804 unsigned unmaskable:1, masked:1, contained:1, mod_proc:1, abstract:1;
|
|
|
805
|
|
|
806 /* Set if this is a module function or subroutine. Note that it is an
|
|
|
807 attribute because it appears as a prefix in the declaration like
|
|
|
808 PURE, etc.. */
|
|
|
809 unsigned module_procedure:1;
|
|
|
810
|
|
|
811 /* Set if a (public) symbol [e.g. generic name] exposes this symbol,
|
|
|
812 which is relevant for private module procedures. */
|
|
|
813 unsigned public_used:1;
|
|
|
814
|
|
|
815 /* This is set if a contained procedure could be declared pure. This is
|
|
|
816 used for certain optimizations that require the result or arguments
|
|
|
817 cannot alias. Note that this is zero for PURE procedures. */
|
|
|
818 unsigned implicit_pure:1;
|
|
|
819
|
|
|
820 /* This is set for a procedure that contains expressions referencing
|
|
|
821 arrays coming from outside its namespace.
|
|
|
822 This is used to force the creation of a temporary when the LHS of
|
|
|
823 an array assignment may be used by an elemental procedure appearing
|
|
|
824 on the RHS. */
|
|
|
825 unsigned array_outer_dependency:1;
|
|
|
826
|
|
|
827 /* This is set if the subroutine doesn't return. Currently, this
|
|
|
828 is only possible for intrinsic subroutines. */
|
|
|
829 unsigned noreturn:1;
|
|
|
830
|
|
|
831 /* Set if this procedure is an alternate entry point. These procedures
|
|
|
832 don't have any code associated, and the backend will turn them into
|
|
|
833 thunks to the master function. */
|
|
|
834 unsigned entry:1;
|
|
|
835
|
|
|
836 /* Set if this is the master function for a procedure with multiple
|
|
|
837 entry points. */
|
|
|
838 unsigned entry_master:1;
|
|
|
839
|
|
|
840 /* Set if this is the master function for a function with multiple
|
|
|
841 entry points where characteristics of the entry points differ. */
|
|
|
842 unsigned mixed_entry_master:1;
|
|
|
843
|
|
|
844 /* Set if a function must always be referenced by an explicit interface. */
|
|
|
845 unsigned always_explicit:1;
|
|
|
846
|
|
|
847 /* Set if the symbol is generated and, hence, standard violations
|
|
|
848 shouldn't be flaged. */
|
|
|
849 unsigned artificial:1;
|
|
|
850
|
|
|
851 /* Set if the symbol has been referenced in an expression. No further
|
|
|
852 modification of type or type parameters is permitted. */
|
|
|
853 unsigned referenced:1;
|
|
|
854
|
|
|
855 /* Set if this is the symbol for the main program. */
|
|
|
856 unsigned is_main_program:1;
|
|
|
857
|
|
|
858 /* Mutually exclusive multibit attributes. */
|
|
|
859 ENUM_BITFIELD (gfc_access) access:2;
|
|
|
860 ENUM_BITFIELD (sym_intent) intent:2;
|
|
|
861 ENUM_BITFIELD (sym_flavor) flavor:4;
|
|
|
862 ENUM_BITFIELD (ifsrc) if_source:2;
|
|
|
863
|
|
|
864 ENUM_BITFIELD (procedure_type) proc:3;
|
|
|
865
|
|
|
866 /* Special attributes for Cray pointers, pointees. */
|
|
|
867 unsigned cray_pointer:1, cray_pointee:1;
|
|
|
868
|
|
|
869 /* The symbol is a derived type with allocatable components, pointer
|
|
|
870 components or private components, procedure pointer components,
|
|
|
871 possibly nested. zero_comp is true if the derived type has no
|
|
|
872 component at all. defined_assign_comp is true if the derived
|
|
|
873 type or a (sub-)component has a typebound defined assignment.
|
|
|
874 unlimited_polymorphic flags the type of the container for these
|
|
|
875 entities. */
|
|
|
876 unsigned alloc_comp:1, pointer_comp:1, proc_pointer_comp:1,
|
|
|
877 private_comp:1, zero_comp:1, coarray_comp:1, lock_comp:1,
|
|
|
878 event_comp:1, defined_assign_comp:1, unlimited_polymorphic:1,
|
|
131
|
879 has_dtio_procs:1, caf_token:1;
|
|
111
|
880
|
|
|
881 /* This is a temporary selector for SELECT TYPE or an associate
|
|
|
882 variable for SELECT_TYPE or ASSOCIATE. */
|
|
|
883 unsigned select_type_temporary:1, associate_var:1;
|
|
|
884
|
|
|
885 /* These are the attributes required for parameterized derived
|
|
|
886 types. */
|
|
|
887 unsigned pdt_kind:1, pdt_len:1, pdt_type:1, pdt_template:1,
|
|
|
888 pdt_array:1, pdt_string:1;
|
|
|
889
|
|
|
890 /* This is omp_{out,in,priv,orig} artificial variable in
|
|
|
891 !$OMP DECLARE REDUCTION. */
|
|
|
892 unsigned omp_udr_artificial_var:1;
|
|
|
893
|
|
|
894 /* Mentioned in OMP DECLARE TARGET. */
|
|
|
895 unsigned omp_declare_target:1;
|
|
|
896 unsigned omp_declare_target_link:1;
|
|
|
897
|
|
|
898 /* Mentioned in OACC DECLARE. */
|
|
|
899 unsigned oacc_declare_create:1;
|
|
|
900 unsigned oacc_declare_copyin:1;
|
|
|
901 unsigned oacc_declare_deviceptr:1;
|
|
|
902 unsigned oacc_declare_device_resident:1;
|
|
|
903 unsigned oacc_declare_link:1;
|
|
|
904
|
|
|
905 /* This is an OpenACC acclerator function at level N - 1 */
|
|
|
906 unsigned oacc_function:3;
|
|
|
907
|
|
|
908 /* Attributes set by compiler extensions (!GCC$ ATTRIBUTES). */
|
|
|
909 unsigned ext_attr:EXT_ATTR_NUM;
|
|
|
910
|
|
|
911 /* The namespace where the attribute has been set. */
|
|
|
912 struct gfc_namespace *volatile_ns, *asynchronous_ns;
|
|
|
913 }
|
|
|
914 symbol_attribute;
|
|
|
915
|
|
|
916
|
|
|
917 /* We need to store source lines as sequences of multibyte source
|
|
|
918 characters. We define here a type wide enough to hold any multibyte
|
|
|
919 source character, just like libcpp does. A 32-bit type is enough. */
|
|
|
920
|
|
|
921 #if HOST_BITS_PER_INT >= 32
|
|
|
922 typedef unsigned int gfc_char_t;
|
|
|
923 #elif HOST_BITS_PER_LONG >= 32
|
|
|
924 typedef unsigned long gfc_char_t;
|
|
|
925 #elif defined(HAVE_LONG_LONG) && (HOST_BITS_PER_LONGLONG >= 32)
|
|
|
926 typedef unsigned long long gfc_char_t;
|
|
|
927 #else
|
|
|
928 # error "Cannot find an integer type with at least 32 bits"
|
|
|
929 #endif
|
|
|
930
|
|
|
931
|
|
|
932 /* The following three structures are used to identify a location in
|
|
|
933 the sources.
|
|
|
934
|
|
|
935 gfc_file is used to maintain a tree of the source files and how
|
|
|
936 they include each other
|
|
|
937
|
|
|
938 gfc_linebuf holds a single line of source code and information
|
|
|
939 which file it resides in
|
|
|
940
|
|
|
941 locus point to the sourceline and the character in the source
|
|
|
942 line.
|
|
|
943 */
|
|
|
944
|
|
|
945 typedef struct gfc_file
|
|
|
946 {
|
|
|
947 struct gfc_file *next, *up;
|
|
|
948 int inclusion_line, line;
|
|
|
949 char *filename;
|
|
|
950 } gfc_file;
|
|
|
951
|
|
|
952 typedef struct gfc_linebuf
|
|
|
953 {
|
|
|
954 source_location location;
|
|
|
955 struct gfc_file *file;
|
|
|
956 struct gfc_linebuf *next;
|
|
|
957
|
|
|
958 int truncated;
|
|
|
959 bool dbg_emitted;
|
|
|
960
|
|
|
961 gfc_char_t line[1];
|
|
|
962 } gfc_linebuf;
|
|
|
963
|
|
|
964 #define gfc_linebuf_header_size (offsetof (gfc_linebuf, line))
|
|
|
965
|
|
|
966 #define gfc_linebuf_linenum(LBUF) (LOCATION_LINE ((LBUF)->location))
|
|
|
967
|
|
|
968 typedef struct
|
|
|
969 {
|
|
|
970 gfc_char_t *nextc;
|
|
|
971 gfc_linebuf *lb;
|
|
|
972 } locus;
|
|
|
973
|
|
|
974 /* In order for the "gfc" format checking to work correctly, you must
|
|
|
975 have declared a typedef locus first. */
|
|
|
976 #if GCC_VERSION >= 4001
|
|
|
977 #define ATTRIBUTE_GCC_GFC(m, n) __attribute__ ((__format__ (__gcc_gfc__, m, n))) ATTRIBUTE_NONNULL(m)
|
|
|
978 #else
|
|
|
979 #define ATTRIBUTE_GCC_GFC(m, n) ATTRIBUTE_NONNULL(m)
|
|
|
980 #endif
|
|
|
981
|
|
|
982
|
|
|
983 /* Suppress error messages or re-enable them. */
|
|
|
984
|
|
|
985 void gfc_push_suppress_errors (void);
|
|
|
986 void gfc_pop_suppress_errors (void);
|
|
|
987
|
|
|
988
|
|
|
989 /* Character length structures hold the expression that gives the
|
|
|
990 length of a character variable. We avoid putting these into
|
|
|
991 gfc_typespec because doing so prevents us from doing structure
|
|
|
992 copies and forces us to deallocate any typespecs we create, as well
|
|
|
993 as structures that contain typespecs. They also can have multiple
|
|
|
994 character typespecs pointing to them.
|
|
|
995
|
|
|
996 These structures form a singly linked list within the current
|
|
|
997 namespace and are deallocated with the namespace. It is possible to
|
|
|
998 end up with gfc_charlen structures that have nothing pointing to them. */
|
|
|
999
|
|
|
1000 typedef struct gfc_charlen
|
|
|
1001 {
|
|
|
1002 struct gfc_expr *length;
|
|
|
1003 struct gfc_charlen *next;
|
|
|
1004 bool length_from_typespec; /* Length from explicit array ctor typespec? */
|
|
|
1005 tree backend_decl;
|
|
|
1006 tree passed_length; /* Length argument explicitly passed. */
|
|
|
1007
|
|
|
1008 int resolved;
|
|
|
1009 }
|
|
|
1010 gfc_charlen;
|
|
|
1011
|
|
|
1012 #define gfc_get_charlen() XCNEW (gfc_charlen)
|
|
|
1013
|
|
|
1014 /* Type specification structure. */
|
|
|
1015 typedef struct
|
|
|
1016 {
|
|
|
1017 bt type;
|
|
|
1018 int kind;
|
|
|
1019
|
|
|
1020 union
|
|
|
1021 {
|
|
|
1022 struct gfc_symbol *derived; /* For derived types only. */
|
|
|
1023 gfc_charlen *cl; /* For character types only. */
|
|
|
1024 int pad; /* For hollerith types only. */
|
|
|
1025 }
|
|
|
1026 u;
|
|
|
1027
|
|
|
1028 struct gfc_symbol *interface; /* For PROCEDURE declarations. */
|
|
|
1029 int is_c_interop;
|
|
|
1030 int is_iso_c;
|
|
|
1031 bt f90_type;
|
|
|
1032 bool deferred;
|
|
|
1033 gfc_symbol *interop_kind;
|
|
|
1034 }
|
|
|
1035 gfc_typespec;
|
|
|
1036
|
|
|
1037 /* Array specification. */
|
|
|
1038 typedef struct
|
|
|
1039 {
|
|
|
1040 int rank; /* A scalar has a rank of 0, an assumed-rank array has -1. */
|
|
|
1041 int corank;
|
|
|
1042 array_type type, cotype;
|
|
|
1043 struct gfc_expr *lower[GFC_MAX_DIMENSIONS], *upper[GFC_MAX_DIMENSIONS];
|
|
|
1044
|
|
|
1045 /* These two fields are used with the Cray Pointer extension. */
|
|
|
1046 bool cray_pointee; /* True iff this spec belongs to a cray pointee. */
|
|
|
1047 bool cp_was_assumed; /* AS_ASSUMED_SIZE cp arrays are converted to
|
|
|
1048 AS_EXPLICIT, but we want to remember that we
|
|
|
1049 did this. */
|
|
|
1050
|
|
|
1051 bool resolved;
|
|
|
1052 }
|
|
|
1053 gfc_array_spec;
|
|
|
1054
|
|
|
1055 #define gfc_get_array_spec() XCNEW (gfc_array_spec)
|
|
|
1056
|
|
|
1057
|
|
|
1058 /* Components of derived types. */
|
|
|
1059 typedef struct gfc_component
|
|
|
1060 {
|
|
|
1061 const char *name;
|
|
|
1062 gfc_typespec ts;
|
|
|
1063
|
|
|
1064 symbol_attribute attr;
|
|
|
1065 gfc_array_spec *as;
|
|
|
1066
|
|
|
1067 tree backend_decl;
|
|
|
1068 /* Used to cache a FIELD_DECL matching this same component
|
|
|
1069 but applied to a different backend containing type that was
|
|
|
1070 generated by gfc_nonrestricted_type. */
|
|
|
1071 tree norestrict_decl;
|
|
|
1072 locus loc;
|
|
|
1073 struct gfc_expr *initializer;
|
|
|
1074 /* Used in parameterized derived type declarations to store parameterized
|
|
|
1075 kind expressions. */
|
|
|
1076 struct gfc_expr *kind_expr;
|
|
|
1077 struct gfc_actual_arglist *param_list;
|
|
|
1078
|
|
|
1079 struct gfc_component *next;
|
|
|
1080
|
|
|
1081 /* Needed for procedure pointer components. */
|
|
|
1082 struct gfc_typebound_proc *tb;
|
|
|
1083 /* When allocatable/pointer and in a coarray the associated token. */
|
|
|
1084 tree caf_token;
|
|
|
1085 }
|
|
|
1086 gfc_component;
|
|
|
1087
|
|
|
1088 #define gfc_get_component() XCNEW (gfc_component)
|
|
|
1089
|
|
|
1090 /* Formal argument lists are lists of symbols. */
|
|
|
1091 typedef struct gfc_formal_arglist
|
|
|
1092 {
|
|
|
1093 /* Symbol representing the argument at this position in the arglist. */
|
|
|
1094 struct gfc_symbol *sym;
|
|
|
1095 /* Points to the next formal argument. */
|
|
|
1096 struct gfc_formal_arglist *next;
|
|
|
1097 }
|
|
|
1098 gfc_formal_arglist;
|
|
|
1099
|
|
|
1100 #define gfc_get_formal_arglist() XCNEW (gfc_formal_arglist)
|
|
|
1101
|
|
|
1102
|
|
|
1103 /* The gfc_actual_arglist structure is for actual arguments and
|
|
|
1104 for type parameter specification lists. */
|
|
|
1105 typedef struct gfc_actual_arglist
|
|
|
1106 {
|
|
|
1107 const char *name;
|
|
|
1108 /* Alternate return label when the expr member is null. */
|
|
|
1109 struct gfc_st_label *label;
|
|
|
1110
|
|
|
1111 /* This is set to the type of an eventual omitted optional
|
|
|
1112 argument. This is used to determine if a hidden string length
|
|
|
1113 argument has to be added to a function call. */
|
|
|
1114 bt missing_arg_type;
|
|
|
1115
|
|
|
1116 gfc_param_spec_type spec_type;
|
|
|
1117
|
|
|
1118 struct gfc_expr *expr;
|
|
|
1119 struct gfc_actual_arglist *next;
|
|
|
1120 }
|
|
|
1121 gfc_actual_arglist;
|
|
|
1122
|
|
|
1123 #define gfc_get_actual_arglist() XCNEW (gfc_actual_arglist)
|
|
|
1124
|
|
|
1125
|
|
|
1126 /* Because a symbol can belong to multiple namelists, they must be
|
|
|
1127 linked externally to the symbol itself. */
|
|
|
1128 typedef struct gfc_namelist
|
|
|
1129 {
|
|
|
1130 struct gfc_symbol *sym;
|
|
|
1131 struct gfc_namelist *next;
|
|
|
1132 }
|
|
|
1133 gfc_namelist;
|
|
|
1134
|
|
|
1135 #define gfc_get_namelist() XCNEW (gfc_namelist)
|
|
|
1136
|
|
|
1137 /* Likewise to gfc_namelist, but contains expressions. */
|
|
|
1138 typedef struct gfc_expr_list
|
|
|
1139 {
|
|
|
1140 struct gfc_expr *expr;
|
|
|
1141 struct gfc_expr_list *next;
|
|
|
1142 }
|
|
|
1143 gfc_expr_list;
|
|
|
1144
|
|
|
1145 #define gfc_get_expr_list() XCNEW (gfc_expr_list)
|
|
|
1146
|
|
|
1147 enum gfc_omp_reduction_op
|
|
|
1148 {
|
|
|
1149 OMP_REDUCTION_NONE = -1,
|
|
|
1150 OMP_REDUCTION_PLUS = INTRINSIC_PLUS,
|
|
|
1151 OMP_REDUCTION_MINUS = INTRINSIC_MINUS,
|
|
|
1152 OMP_REDUCTION_TIMES = INTRINSIC_TIMES,
|
|
|
1153 OMP_REDUCTION_AND = INTRINSIC_AND,
|
|
|
1154 OMP_REDUCTION_OR = INTRINSIC_OR,
|
|
|
1155 OMP_REDUCTION_EQV = INTRINSIC_EQV,
|
|
|
1156 OMP_REDUCTION_NEQV = INTRINSIC_NEQV,
|
|
|
1157 OMP_REDUCTION_MAX = GFC_INTRINSIC_END,
|
|
|
1158 OMP_REDUCTION_MIN,
|
|
|
1159 OMP_REDUCTION_IAND,
|
|
|
1160 OMP_REDUCTION_IOR,
|
|
|
1161 OMP_REDUCTION_IEOR,
|
|
|
1162 OMP_REDUCTION_USER
|
|
|
1163 };
|
|
|
1164
|
|
|
1165 enum gfc_omp_depend_op
|
|
|
1166 {
|
|
|
1167 OMP_DEPEND_IN,
|
|
|
1168 OMP_DEPEND_OUT,
|
|
|
1169 OMP_DEPEND_INOUT,
|
|
|
1170 OMP_DEPEND_SINK_FIRST,
|
|
|
1171 OMP_DEPEND_SINK
|
|
|
1172 };
|
|
|
1173
|
|
|
1174 enum gfc_omp_map_op
|
|
|
1175 {
|
|
|
1176 OMP_MAP_ALLOC,
|
|
|
1177 OMP_MAP_TO,
|
|
|
1178 OMP_MAP_FROM,
|
|
|
1179 OMP_MAP_TOFROM,
|
|
|
1180 OMP_MAP_DELETE,
|
|
|
1181 OMP_MAP_FORCE_ALLOC,
|
|
|
1182 OMP_MAP_FORCE_TO,
|
|
|
1183 OMP_MAP_FORCE_FROM,
|
|
|
1184 OMP_MAP_FORCE_TOFROM,
|
|
|
1185 OMP_MAP_FORCE_PRESENT,
|
|
|
1186 OMP_MAP_FORCE_DEVICEPTR,
|
|
|
1187 OMP_MAP_DEVICE_RESIDENT,
|
|
|
1188 OMP_MAP_LINK,
|
|
|
1189 OMP_MAP_RELEASE,
|
|
|
1190 OMP_MAP_ALWAYS_TO,
|
|
|
1191 OMP_MAP_ALWAYS_FROM,
|
|
|
1192 OMP_MAP_ALWAYS_TOFROM
|
|
|
1193 };
|
|
|
1194
|
|
|
1195 enum gfc_omp_linear_op
|
|
|
1196 {
|
|
|
1197 OMP_LINEAR_DEFAULT,
|
|
|
1198 OMP_LINEAR_REF,
|
|
|
1199 OMP_LINEAR_VAL,
|
|
|
1200 OMP_LINEAR_UVAL
|
|
|
1201 };
|
|
|
1202
|
|
|
1203 /* For use in OpenMP clauses in case we need extra information
|
|
|
1204 (aligned clause alignment, linear clause step, etc.). */
|
|
|
1205
|
|
|
1206 typedef struct gfc_omp_namelist
|
|
|
1207 {
|
|
|
1208 struct gfc_symbol *sym;
|
|
|
1209 struct gfc_expr *expr;
|
|
|
1210 union
|
|
|
1211 {
|
|
|
1212 gfc_omp_reduction_op reduction_op;
|
|
|
1213 gfc_omp_depend_op depend_op;
|
|
|
1214 gfc_omp_map_op map_op;
|
|
|
1215 gfc_omp_linear_op linear_op;
|
|
|
1216 struct gfc_common_head *common;
|
|
|
1217 } u;
|
|
|
1218 struct gfc_omp_namelist_udr *udr;
|
|
|
1219 struct gfc_omp_namelist *next;
|
|
|
1220 locus where;
|
|
|
1221 }
|
|
|
1222 gfc_omp_namelist;
|
|
|
1223
|
|
|
1224 #define gfc_get_omp_namelist() XCNEW (gfc_omp_namelist)
|
|
|
1225
|
|
|
1226 enum
|
|
|
1227 {
|
|
|
1228 OMP_LIST_FIRST,
|
|
|
1229 OMP_LIST_PRIVATE = OMP_LIST_FIRST,
|
|
|
1230 OMP_LIST_FIRSTPRIVATE,
|
|
|
1231 OMP_LIST_LASTPRIVATE,
|
|
|
1232 OMP_LIST_COPYPRIVATE,
|
|
|
1233 OMP_LIST_SHARED,
|
|
|
1234 OMP_LIST_COPYIN,
|
|
|
1235 OMP_LIST_UNIFORM,
|
|
|
1236 OMP_LIST_ALIGNED,
|
|
|
1237 OMP_LIST_LINEAR,
|
|
|
1238 OMP_LIST_DEPEND,
|
|
|
1239 OMP_LIST_MAP,
|
|
|
1240 OMP_LIST_TO,
|
|
|
1241 OMP_LIST_FROM,
|
|
|
1242 OMP_LIST_REDUCTION,
|
|
|
1243 OMP_LIST_DEVICE_RESIDENT,
|
|
|
1244 OMP_LIST_LINK,
|
|
|
1245 OMP_LIST_USE_DEVICE,
|
|
|
1246 OMP_LIST_CACHE,
|
|
|
1247 OMP_LIST_IS_DEVICE_PTR,
|
|
|
1248 OMP_LIST_USE_DEVICE_PTR,
|
|
|
1249 OMP_LIST_NUM
|
|
|
1250 };
|
|
|
1251
|
|
|
1252 /* Because a symbol can belong to multiple namelists, they must be
|
|
|
1253 linked externally to the symbol itself. */
|
|
|
1254
|
|
|
1255 enum gfc_omp_sched_kind
|
|
|
1256 {
|
|
|
1257 OMP_SCHED_NONE,
|
|
|
1258 OMP_SCHED_STATIC,
|
|
|
1259 OMP_SCHED_DYNAMIC,
|
|
|
1260 OMP_SCHED_GUIDED,
|
|
|
1261 OMP_SCHED_RUNTIME,
|
|
|
1262 OMP_SCHED_AUTO
|
|
|
1263 };
|
|
|
1264
|
|
|
1265 enum gfc_omp_default_sharing
|
|
|
1266 {
|
|
|
1267 OMP_DEFAULT_UNKNOWN,
|
|
|
1268 OMP_DEFAULT_NONE,
|
|
|
1269 OMP_DEFAULT_PRIVATE,
|
|
|
1270 OMP_DEFAULT_SHARED,
|
|
|
1271 OMP_DEFAULT_FIRSTPRIVATE,
|
|
|
1272 OMP_DEFAULT_PRESENT
|
|
|
1273 };
|
|
|
1274
|
|
|
1275 enum gfc_omp_proc_bind_kind
|
|
|
1276 {
|
|
|
1277 OMP_PROC_BIND_UNKNOWN,
|
|
|
1278 OMP_PROC_BIND_MASTER,
|
|
|
1279 OMP_PROC_BIND_SPREAD,
|
|
|
1280 OMP_PROC_BIND_CLOSE
|
|
|
1281 };
|
|
|
1282
|
|
|
1283 enum gfc_omp_cancel_kind
|
|
|
1284 {
|
|
|
1285 OMP_CANCEL_UNKNOWN,
|
|
|
1286 OMP_CANCEL_PARALLEL,
|
|
|
1287 OMP_CANCEL_SECTIONS,
|
|
|
1288 OMP_CANCEL_DO,
|
|
|
1289 OMP_CANCEL_TASKGROUP
|
|
|
1290 };
|
|
|
1291
|
|
|
1292 enum gfc_omp_if_kind
|
|
|
1293 {
|
|
|
1294 OMP_IF_PARALLEL,
|
|
|
1295 OMP_IF_TASK,
|
|
|
1296 OMP_IF_TASKLOOP,
|
|
|
1297 OMP_IF_TARGET,
|
|
|
1298 OMP_IF_TARGET_DATA,
|
|
|
1299 OMP_IF_TARGET_UPDATE,
|
|
|
1300 OMP_IF_TARGET_ENTER_DATA,
|
|
|
1301 OMP_IF_TARGET_EXIT_DATA,
|
|
|
1302 OMP_IF_LAST
|
|
|
1303 };
|
|
|
1304
|
|
|
1305 typedef struct gfc_omp_clauses
|
|
|
1306 {
|
|
|
1307 struct gfc_expr *if_expr;
|
|
|
1308 struct gfc_expr *final_expr;
|
|
|
1309 struct gfc_expr *num_threads;
|
|
|
1310 gfc_omp_namelist *lists[OMP_LIST_NUM];
|
|
|
1311 enum gfc_omp_sched_kind sched_kind;
|
|
|
1312 struct gfc_expr *chunk_size;
|
|
|
1313 enum gfc_omp_default_sharing default_sharing;
|
|
|
1314 int collapse, orderedc;
|
|
|
1315 bool nowait, ordered, untied, mergeable;
|
|
|
1316 bool inbranch, notinbranch, defaultmap, nogroup;
|
|
|
1317 bool sched_simd, sched_monotonic, sched_nonmonotonic;
|
|
|
1318 bool simd, threads, depend_source;
|
|
|
1319 enum gfc_omp_cancel_kind cancel;
|
|
|
1320 enum gfc_omp_proc_bind_kind proc_bind;
|
|
|
1321 struct gfc_expr *safelen_expr;
|
|
|
1322 struct gfc_expr *simdlen_expr;
|
|
|
1323 struct gfc_expr *num_teams;
|
|
|
1324 struct gfc_expr *device;
|
|
|
1325 struct gfc_expr *thread_limit;
|
|
|
1326 struct gfc_expr *grainsize;
|
|
|
1327 struct gfc_expr *hint;
|
|
|
1328 struct gfc_expr *num_tasks;
|
|
|
1329 struct gfc_expr *priority;
|
|
|
1330 struct gfc_expr *if_exprs[OMP_IF_LAST];
|
|
|
1331 enum gfc_omp_sched_kind dist_sched_kind;
|
|
|
1332 struct gfc_expr *dist_chunk_size;
|
|
|
1333 const char *critical_name;
|
|
|
1334
|
|
|
1335 /* OpenACC. */
|
|
|
1336 struct gfc_expr *async_expr;
|
|
|
1337 struct gfc_expr *gang_static_expr;
|
|
|
1338 struct gfc_expr *gang_num_expr;
|
|
|
1339 struct gfc_expr *worker_expr;
|
|
|
1340 struct gfc_expr *vector_expr;
|
|
|
1341 struct gfc_expr *num_gangs_expr;
|
|
|
1342 struct gfc_expr *num_workers_expr;
|
|
|
1343 struct gfc_expr *vector_length_expr;
|
|
|
1344 gfc_expr_list *wait_list;
|
|
|
1345 gfc_expr_list *tile_list;
|
|
|
1346 unsigned async:1, gang:1, worker:1, vector:1, seq:1, independent:1;
|
|
|
1347 unsigned wait:1, par_auto:1, gang_static:1;
|
|
131
|
1348 unsigned if_present:1, finalize:1;
|
|
111
|
1349 locus loc;
|
|
|
1350
|
|
|
1351 }
|
|
|
1352 gfc_omp_clauses;
|
|
|
1353
|
|
|
1354 #define gfc_get_omp_clauses() XCNEW (gfc_omp_clauses)
|
|
|
1355
|
|
|
1356
|
|
|
1357 /* Node in the linked list used for storing !$oacc declare constructs. */
|
|
|
1358
|
|
|
1359 typedef struct gfc_oacc_declare
|
|
|
1360 {
|
|
|
1361 struct gfc_oacc_declare *next;
|
|
|
1362 bool module_var;
|
|
|
1363 gfc_omp_clauses *clauses;
|
|
|
1364 locus loc;
|
|
|
1365 }
|
|
|
1366 gfc_oacc_declare;
|
|
|
1367
|
|
|
1368 #define gfc_get_oacc_declare() XCNEW (gfc_oacc_declare)
|
|
|
1369
|
|
|
1370
|
|
|
1371 /* Node in the linked list used for storing !$omp declare simd constructs. */
|
|
|
1372
|
|
|
1373 typedef struct gfc_omp_declare_simd
|
|
|
1374 {
|
|
|
1375 struct gfc_omp_declare_simd *next;
|
|
|
1376 locus where; /* Where the !$omp declare simd construct occurred. */
|
|
|
1377
|
|
|
1378 gfc_symbol *proc_name;
|
|
|
1379
|
|
|
1380 gfc_omp_clauses *clauses;
|
|
|
1381 }
|
|
|
1382 gfc_omp_declare_simd;
|
|
|
1383 #define gfc_get_omp_declare_simd() XCNEW (gfc_omp_declare_simd)
|
|
|
1384
|
|
|
1385 typedef struct gfc_omp_udr
|
|
|
1386 {
|
|
|
1387 struct gfc_omp_udr *next;
|
|
|
1388 locus where; /* Where the !$omp declare reduction construct occurred. */
|
|
|
1389
|
|
|
1390 const char *name;
|
|
|
1391 gfc_typespec ts;
|
|
|
1392 gfc_omp_reduction_op rop;
|
|
|
1393
|
|
|
1394 struct gfc_symbol *omp_out;
|
|
|
1395 struct gfc_symbol *omp_in;
|
|
|
1396 struct gfc_namespace *combiner_ns;
|
|
|
1397
|
|
|
1398 struct gfc_symbol *omp_priv;
|
|
|
1399 struct gfc_symbol *omp_orig;
|
|
|
1400 struct gfc_namespace *initializer_ns;
|
|
|
1401 }
|
|
|
1402 gfc_omp_udr;
|
|
|
1403 #define gfc_get_omp_udr() XCNEW (gfc_omp_udr)
|
|
|
1404
|
|
|
1405 typedef struct gfc_omp_namelist_udr
|
|
|
1406 {
|
|
|
1407 struct gfc_omp_udr *udr;
|
|
|
1408 struct gfc_code *combiner;
|
|
|
1409 struct gfc_code *initializer;
|
|
|
1410 }
|
|
|
1411 gfc_omp_namelist_udr;
|
|
|
1412 #define gfc_get_omp_namelist_udr() XCNEW (gfc_omp_namelist_udr)
|
|
|
1413
|
|
|
1414 /* The gfc_st_label structure is a BBT attached to a namespace that
|
|
|
1415 records the usage of statement labels within that space. */
|
|
|
1416
|
|
|
1417 typedef struct gfc_st_label
|
|
|
1418 {
|
|
|
1419 BBT_HEADER(gfc_st_label);
|
|
|
1420
|
|
|
1421 int value;
|
|
|
1422
|
|
|
1423 gfc_sl_type defined, referenced;
|
|
|
1424
|
|
|
1425 struct gfc_expr *format;
|
|
|
1426
|
|
|
1427 tree backend_decl;
|
|
|
1428
|
|
|
1429 locus where;
|
|
|
1430
|
|
|
1431 gfc_namespace *ns;
|
|
|
1432 }
|
|
|
1433 gfc_st_label;
|
|
|
1434
|
|
|
1435
|
|
|
1436 /* gfc_interface()-- Interfaces are lists of symbols strung together. */
|
|
|
1437 typedef struct gfc_interface
|
|
|
1438 {
|
|
|
1439 struct gfc_symbol *sym;
|
|
|
1440 locus where;
|
|
|
1441 struct gfc_interface *next;
|
|
|
1442 }
|
|
|
1443 gfc_interface;
|
|
|
1444
|
|
|
1445 #define gfc_get_interface() XCNEW (gfc_interface)
|
|
|
1446
|
|
|
1447 /* User operator nodes. These are like stripped down symbols. */
|
|
|
1448 typedef struct
|
|
|
1449 {
|
|
|
1450 const char *name;
|
|
|
1451
|
|
|
1452 gfc_interface *op;
|
|
|
1453 struct gfc_namespace *ns;
|
|
|
1454 gfc_access access;
|
|
|
1455 }
|
|
|
1456 gfc_user_op;
|
|
|
1457
|
|
|
1458
|
|
|
1459 /* A list of specific bindings that are associated with a generic spec. */
|
|
|
1460 typedef struct gfc_tbp_generic
|
|
|
1461 {
|
|
|
1462 /* The parser sets specific_st, upon resolution we look for the corresponding
|
|
|
1463 gfc_typebound_proc and set specific for further use. */
|
|
|
1464 struct gfc_symtree* specific_st;
|
|
|
1465 struct gfc_typebound_proc* specific;
|
|
|
1466
|
|
|
1467 struct gfc_tbp_generic* next;
|
|
|
1468 bool is_operator;
|
|
|
1469 }
|
|
|
1470 gfc_tbp_generic;
|
|
|
1471
|
|
|
1472 #define gfc_get_tbp_generic() XCNEW (gfc_tbp_generic)
|
|
|
1473
|
|
|
1474
|
|
|
1475 /* Data needed for type-bound procedures. */
|
|
|
1476 typedef struct gfc_typebound_proc
|
|
|
1477 {
|
|
|
1478 locus where; /* Where the PROCEDURE/GENERIC definition was. */
|
|
|
1479
|
|
|
1480 union
|
|
|
1481 {
|
|
|
1482 struct gfc_symtree* specific; /* The interface if DEFERRED. */
|
|
|
1483 gfc_tbp_generic* generic;
|
|
|
1484 }
|
|
|
1485 u;
|
|
|
1486
|
|
|
1487 gfc_access access;
|
|
|
1488 const char* pass_arg; /* Argument-name for PASS. NULL if not specified. */
|
|
|
1489
|
|
|
1490 /* The overridden type-bound proc (or GENERIC with this name in the
|
|
|
1491 parent-type) or NULL if non. */
|
|
|
1492 struct gfc_typebound_proc* overridden;
|
|
|
1493
|
|
|
1494 /* Once resolved, we use the position of pass_arg in the formal arglist of
|
|
|
1495 the binding-target procedure to identify it. The first argument has
|
|
|
1496 number 1 here, the second 2, and so on. */
|
|
|
1497 unsigned pass_arg_num;
|
|
|
1498
|
|
|
1499 unsigned nopass:1; /* Whether we have NOPASS (PASS otherwise). */
|
|
|
1500 unsigned non_overridable:1;
|
|
|
1501 unsigned deferred:1;
|
|
|
1502 unsigned is_generic:1;
|
|
|
1503 unsigned function:1, subroutine:1;
|
|
|
1504 unsigned error:1; /* Ignore it, when an error occurred during resolution. */
|
|
|
1505 unsigned ppc:1;
|
|
|
1506 }
|
|
|
1507 gfc_typebound_proc;
|
|
|
1508
|
|
|
1509
|
|
|
1510 /* Symbol nodes. These are important things. They are what the
|
|
|
1511 standard refers to as "entities". The possibly multiple names that
|
|
|
1512 refer to the same entity are accomplished by a binary tree of
|
|
|
1513 symtree structures that is balanced by the red-black method-- more
|
|
|
1514 than one symtree node can point to any given symbol. */
|
|
|
1515
|
|
|
1516 typedef struct gfc_symbol
|
|
|
1517 {
|
|
|
1518 const char *name; /* Primary name, before renaming */
|
|
|
1519 const char *module; /* Module this symbol came from */
|
|
|
1520 locus declared_at;
|
|
|
1521
|
|
|
1522 gfc_typespec ts;
|
|
|
1523 symbol_attribute attr;
|
|
|
1524
|
|
|
1525 /* The formal member points to the formal argument list if the
|
|
|
1526 symbol is a function or subroutine name. If the symbol is a
|
|
|
1527 generic name, the generic member points to the list of
|
|
|
1528 interfaces. */
|
|
|
1529
|
|
|
1530 gfc_interface *generic;
|
|
|
1531 gfc_access component_access;
|
|
|
1532
|
|
|
1533 gfc_formal_arglist *formal;
|
|
|
1534 struct gfc_namespace *formal_ns;
|
|
|
1535 struct gfc_namespace *f2k_derived;
|
|
|
1536
|
|
|
1537 /* List of PDT parameter expressions */
|
|
|
1538 struct gfc_actual_arglist *param_list;
|
|
|
1539
|
|
|
1540 struct gfc_expr *value; /* Parameter/Initializer value */
|
|
|
1541 gfc_array_spec *as;
|
|
|
1542 struct gfc_symbol *result; /* function result symbol */
|
|
|
1543 gfc_component *components; /* Derived type components */
|
|
|
1544
|
|
|
1545 /* Defined only for Cray pointees; points to their pointer. */
|
|
|
1546 struct gfc_symbol *cp_pointer;
|
|
|
1547
|
|
|
1548 int entry_id; /* Used in resolve.c for entries. */
|
|
|
1549
|
|
|
1550 /* CLASS hashed name for declared and dynamic types in the class. */
|
|
|
1551 int hash_value;
|
|
|
1552
|
|
|
1553 struct gfc_symbol *common_next; /* Links for COMMON syms */
|
|
|
1554
|
|
|
1555 /* This is only used for pointer comparisons to check if symbols
|
|
|
1556 are in the same common block.
|
|
|
1557 In opposition to common_block, the common_head pointer takes into account
|
|
|
1558 equivalences: if A is in a common block C and A and B are in equivalence,
|
|
|
1559 then both A and B have common_head pointing to C, while A's common_block
|
|
|
1560 points to C and B's is NULL. */
|
|
|
1561 struct gfc_common_head* common_head;
|
|
|
1562
|
|
|
1563 /* Make sure setup code for dummy arguments is generated in the correct
|
|
|
1564 order. */
|
|
|
1565 int dummy_order;
|
|
|
1566
|
|
|
1567 gfc_namelist *namelist, *namelist_tail;
|
|
|
1568
|
|
|
1569 /* Change management fields. Symbols that might be modified by the
|
|
|
1570 current statement have the mark member nonzero. Of these symbols,
|
|
|
1571 symbols with old_symbol equal to NULL are symbols created within
|
|
|
1572 the current statement. Otherwise, old_symbol points to a copy of
|
|
|
1573 the old symbol. gfc_new is used in symbol.c to flag new symbols. */
|
|
|
1574 struct gfc_symbol *old_symbol;
|
|
|
1575 unsigned mark:1, gfc_new:1;
|
|
|
1576
|
|
|
1577 /* The tlink field is used in the front end to carry the module
|
|
|
1578 declaration of separate module procedures so that the characteristics
|
|
|
1579 can be compared with the corresponding declaration in a submodule. In
|
|
|
1580 translation this field carries a linked list of symbols that require
|
|
|
1581 deferred initialization. */
|
|
|
1582 struct gfc_symbol *tlink;
|
|
|
1583
|
|
|
1584 /* Nonzero if all equivalences associated with this symbol have been
|
|
|
1585 processed. */
|
|
|
1586 unsigned equiv_built:1;
|
|
|
1587 /* Set if this variable is used as an index name in a FORALL. */
|
|
|
1588 unsigned forall_index:1;
|
|
|
1589 /* Set if the symbol is used in a function result specification . */
|
|
|
1590 unsigned fn_result_spec:1;
|
|
|
1591 /* Used to avoid multiple resolutions of a single symbol. */
|
|
|
1592 unsigned resolved:1;
|
|
|
1593 /* Set if this is a module function or subroutine with the
|
|
|
1594 abreviated declaration in a submodule. */
|
|
|
1595 unsigned abr_modproc_decl:1;
|
|
|
1596
|
|
|
1597 int refs;
|
|
|
1598 struct gfc_namespace *ns; /* namespace containing this symbol */
|
|
|
1599
|
|
|
1600 tree backend_decl;
|
|
|
1601
|
|
|
1602 /* Identity of the intrinsic module the symbol comes from, or
|
|
|
1603 INTMOD_NONE if it's not imported from a intrinsic module. */
|
|
|
1604 intmod_id from_intmod;
|
|
|
1605 /* Identity of the symbol from intrinsic modules, from enums maintained
|
|
|
1606 separately by each intrinsic module. Used together with from_intmod,
|
|
|
1607 it uniquely identifies a symbol from an intrinsic module. */
|
|
|
1608 int intmod_sym_id;
|
|
|
1609
|
|
|
1610 /* This may be repetitive, since the typespec now has a binding
|
|
|
1611 label field. */
|
|
|
1612 const char* binding_label;
|
|
|
1613 /* Store a reference to the common_block, if this symbol is in one. */
|
|
|
1614 struct gfc_common_head *common_block;
|
|
|
1615
|
|
|
1616 /* Link to corresponding association-list if this is an associate name. */
|
|
|
1617 struct gfc_association_list *assoc;
|
|
131
|
1618
|
|
|
1619 /* Link to next entry in derived type list */
|
|
|
1620 struct gfc_symbol *dt_next;
|
|
111
|
1621 }
|
|
|
1622 gfc_symbol;
|
|
|
1623
|
|
|
1624
|
|
|
1625 struct gfc_undo_change_set
|
|
|
1626 {
|
|
|
1627 vec<gfc_symbol *> syms;
|
|
|
1628 vec<gfc_typebound_proc *> tbps;
|
|
|
1629 gfc_undo_change_set *previous;
|
|
|
1630 };
|
|
|
1631
|
|
|
1632
|
|
|
1633 /* This structure is used to keep track of symbols in common blocks. */
|
|
|
1634 typedef struct gfc_common_head
|
|
|
1635 {
|
|
|
1636 locus where;
|
|
|
1637 char use_assoc, saved, threadprivate;
|
|
|
1638 unsigned char omp_declare_target : 1;
|
|
|
1639 unsigned char omp_declare_target_link : 1;
|
|
|
1640 char name[GFC_MAX_SYMBOL_LEN + 1];
|
|
|
1641 struct gfc_symbol *head;
|
|
|
1642 const char* binding_label;
|
|
|
1643 int is_bind_c;
|
|
|
1644 int refs;
|
|
|
1645 }
|
|
|
1646 gfc_common_head;
|
|
|
1647
|
|
|
1648 #define gfc_get_common_head() XCNEW (gfc_common_head)
|
|
|
1649
|
|
|
1650
|
|
|
1651 /* A list of all the alternate entry points for a procedure. */
|
|
|
1652
|
|
|
1653 typedef struct gfc_entry_list
|
|
|
1654 {
|
|
|
1655 /* The symbol for this entry point. */
|
|
|
1656 gfc_symbol *sym;
|
|
|
1657 /* The zero-based id of this entry point. */
|
|
|
1658 int id;
|
|
|
1659 /* The LABEL_EXPR marking this entry point. */
|
|
|
1660 tree label;
|
|
|
1661 /* The next item in the list. */
|
|
|
1662 struct gfc_entry_list *next;
|
|
|
1663 }
|
|
|
1664 gfc_entry_list;
|
|
|
1665
|
|
|
1666 #define gfc_get_entry_list() XCNEW (gfc_entry_list)
|
|
|
1667
|
|
|
1668 /* Lists of rename info for the USE statement. */
|
|
|
1669
|
|
|
1670 typedef struct gfc_use_rename
|
|
|
1671 {
|
|
|
1672 char local_name[GFC_MAX_SYMBOL_LEN + 1], use_name[GFC_MAX_SYMBOL_LEN + 1];
|
|
|
1673 struct gfc_use_rename *next;
|
|
|
1674 int found;
|
|
|
1675 gfc_intrinsic_op op;
|
|
|
1676 locus where;
|
|
|
1677 }
|
|
|
1678 gfc_use_rename;
|
|
|
1679
|
|
|
1680 #define gfc_get_use_rename() XCNEW (gfc_use_rename);
|
|
|
1681
|
|
|
1682 /* A list of all USE statements in a namespace. */
|
|
|
1683
|
|
|
1684 typedef struct gfc_use_list
|
|
|
1685 {
|
|
|
1686 const char *module_name;
|
|
|
1687 const char *submodule_name;
|
|
|
1688 bool intrinsic;
|
|
|
1689 bool non_intrinsic;
|
|
|
1690 bool only_flag;
|
|
|
1691 struct gfc_use_rename *rename;
|
|
|
1692 locus where;
|
|
|
1693 /* Next USE statement. */
|
|
|
1694 struct gfc_use_list *next;
|
|
|
1695 }
|
|
|
1696 gfc_use_list;
|
|
|
1697
|
|
|
1698 #define gfc_get_use_list() XCNEW (gfc_use_list)
|
|
|
1699
|
|
|
1700 /* Within a namespace, symbols are pointed to by symtree nodes that
|
|
|
1701 are linked together in a balanced binary tree. There can be
|
|
|
1702 several symtrees pointing to the same symbol node via USE
|
|
|
1703 statements. */
|
|
|
1704
|
|
|
1705 typedef struct gfc_symtree
|
|
|
1706 {
|
|
|
1707 BBT_HEADER (gfc_symtree);
|
|
|
1708 const char *name;
|
|
|
1709 int ambiguous;
|
|
|
1710 union
|
|
|
1711 {
|
|
|
1712 gfc_symbol *sym; /* Symbol associated with this node */
|
|
|
1713 gfc_user_op *uop;
|
|
|
1714 gfc_common_head *common;
|
|
|
1715 gfc_typebound_proc *tb;
|
|
|
1716 gfc_omp_udr *omp_udr;
|
|
|
1717 }
|
|
|
1718 n;
|
|
|
1719 }
|
|
|
1720 gfc_symtree;
|
|
|
1721
|
|
131
|
1722 /* A list of all derived types. */
|
|
|
1723 extern gfc_symbol *gfc_derived_types;
|
|
111
|
1724
|
|
|
1725 typedef struct gfc_oacc_routine_name
|
|
|
1726 {
|
|
|
1727 struct gfc_symbol *sym;
|
|
|
1728 struct gfc_omp_clauses *clauses;
|
|
|
1729 struct gfc_oacc_routine_name *next;
|
|
|
1730 }
|
|
|
1731 gfc_oacc_routine_name;
|
|
|
1732
|
|
|
1733 #define gfc_get_oacc_routine_name() XCNEW (gfc_oacc_routine_name)
|
|
|
1734
|
|
|
1735 /* A namespace describes the contents of procedure, module, interface block
|
|
|
1736 or BLOCK construct. */
|
|
|
1737 /* ??? Anything else use these? */
|
|
|
1738
|
|
|
1739 typedef struct gfc_namespace
|
|
|
1740 {
|
|
|
1741 /* Tree containing all the symbols in this namespace. */
|
|
|
1742 gfc_symtree *sym_root;
|
|
|
1743 /* Tree containing all the user-defined operators in the namespace. */
|
|
|
1744 gfc_symtree *uop_root;
|
|
|
1745 /* Tree containing all the common blocks. */
|
|
|
1746 gfc_symtree *common_root;
|
|
|
1747 /* Tree containing all the OpenMP user defined reductions. */
|
|
|
1748 gfc_symtree *omp_udr_root;
|
|
|
1749
|
|
|
1750 /* Tree containing type-bound procedures. */
|
|
|
1751 gfc_symtree *tb_sym_root;
|
|
|
1752 /* Type-bound user operators. */
|
|
|
1753 gfc_symtree *tb_uop_root;
|
|
|
1754 /* For derived-types, store type-bound intrinsic operators here. */
|
|
|
1755 gfc_typebound_proc *tb_op[GFC_INTRINSIC_OPS];
|
|
|
1756 /* Linked list of finalizer procedures. */
|
|
|
1757 struct gfc_finalizer *finalizers;
|
|
|
1758
|
|
|
1759 /* If set_flag[letter] is set, an implicit type has been set for letter. */
|
|
|
1760 int set_flag[GFC_LETTERS];
|
|
|
1761 /* Keeps track of the implicit types associated with the letters. */
|
|
|
1762 gfc_typespec default_type[GFC_LETTERS];
|
|
|
1763 /* Store the positions of IMPLICIT statements. */
|
|
|
1764 locus implicit_loc[GFC_LETTERS];
|
|
|
1765
|
|
|
1766 /* If this is a namespace of a procedure, this points to the procedure. */
|
|
|
1767 struct gfc_symbol *proc_name;
|
|
|
1768 /* If this is the namespace of a unit which contains executable
|
|
|
1769 code, this points to it. */
|
|
|
1770 struct gfc_code *code;
|
|
|
1771
|
|
|
1772 /* Points to the equivalences set up in this namespace. */
|
|
|
1773 struct gfc_equiv *equiv, *old_equiv;
|
|
|
1774
|
|
|
1775 /* Points to the equivalence groups produced by trans_common. */
|
|
|
1776 struct gfc_equiv_list *equiv_lists;
|
|
|
1777
|
|
|
1778 gfc_interface *op[GFC_INTRINSIC_OPS];
|
|
|
1779
|
|
|
1780 /* Points to the parent namespace, i.e. the namespace of a module or
|
|
|
1781 procedure in which the procedure belonging to this namespace is
|
|
|
1782 contained. The parent namespace points to this namespace either
|
|
|
1783 directly via CONTAINED, or indirectly via the chain built by
|
|
|
1784 SIBLING. */
|
|
|
1785 struct gfc_namespace *parent;
|
|
|
1786 /* CONTAINED points to the first contained namespace. Sibling
|
|
|
1787 namespaces are chained via SIBLING. */
|
|
|
1788 struct gfc_namespace *contained, *sibling;
|
|
|
1789
|
|
|
1790 gfc_common_head blank_common;
|
|
|
1791 gfc_access default_access, operator_access[GFC_INTRINSIC_OPS];
|
|
|
1792
|
|
|
1793 gfc_st_label *st_labels;
|
|
|
1794 /* This list holds information about all the data initializers in
|
|
|
1795 this namespace. */
|
|
|
1796 struct gfc_data *data, *old_data;
|
|
|
1797
|
|
|
1798 /* !$ACC DECLARE. */
|
|
|
1799 gfc_oacc_declare *oacc_declare;
|
|
|
1800
|
|
|
1801 /* !$ACC ROUTINE clauses. */
|
|
|
1802 gfc_omp_clauses *oacc_routine_clauses;
|
|
|
1803
|
|
|
1804 /* !$ACC ROUTINE names. */
|
|
|
1805 gfc_oacc_routine_name *oacc_routine_names;
|
|
|
1806
|
|
|
1807 gfc_charlen *cl_list;
|
|
|
1808
|
|
131
|
1809 gfc_symbol *derived_types;
|
|
111
|
1810
|
|
|
1811 int save_all, seen_save, seen_implicit_none;
|
|
|
1812
|
|
|
1813 /* Normally we don't need to refcount namespaces. However when we read
|
|
|
1814 a module containing a function with multiple entry points, this
|
|
|
1815 will appear as several functions with the same formal namespace. */
|
|
|
1816 int refs;
|
|
|
1817
|
|
|
1818 /* A list of all alternate entry points to this procedure (or NULL). */
|
|
|
1819 gfc_entry_list *entries;
|
|
|
1820
|
|
|
1821 /* A list of USE statements in this namespace. */
|
|
|
1822 gfc_use_list *use_stmts;
|
|
|
1823
|
|
|
1824 /* Linked list of !$omp declare simd constructs. */
|
|
|
1825 struct gfc_omp_declare_simd *omp_declare_simd;
|
|
|
1826
|
|
|
1827 /* Set to 1 if namespace is a BLOCK DATA program unit. */
|
|
|
1828 unsigned is_block_data:1;
|
|
|
1829
|
|
|
1830 /* Set to 1 if namespace is an interface body with "IMPORT" used. */
|
|
|
1831 unsigned has_import_set:1;
|
|
|
1832
|
|
|
1833 /* Set to 1 if the namespace uses "IMPLICT NONE (export)". */
|
|
|
1834 unsigned has_implicit_none_export:1;
|
|
|
1835
|
|
|
1836 /* Set to 1 if resolved has been called for this namespace.
|
|
|
1837 Holds -1 during resolution. */
|
|
|
1838 signed resolved:2;
|
|
|
1839
|
|
|
1840 /* Set when resolve_types has been called for this namespace. */
|
|
|
1841 unsigned types_resolved:1;
|
|
|
1842
|
|
|
1843 /* Set to 1 if code has been generated for this namespace. */
|
|
|
1844 unsigned translated:1;
|
|
|
1845
|
|
|
1846 /* Set to 1 if symbols in this namespace should be 'construct entities',
|
|
|
1847 i.e. for BLOCK local variables. */
|
|
|
1848 unsigned construct_entities:1;
|
|
|
1849
|
|
|
1850 /* Set to 1 for !$OMP DECLARE REDUCTION namespaces. */
|
|
|
1851 unsigned omp_udr_ns:1;
|
|
|
1852
|
|
|
1853 /* Set to 1 for !$ACC ROUTINE namespaces. */
|
|
|
1854 unsigned oacc_routine:1;
|
|
|
1855 }
|
|
|
1856 gfc_namespace;
|
|
|
1857
|
|
|
1858 extern gfc_namespace *gfc_current_ns;
|
|
|
1859 extern gfc_namespace *gfc_global_ns_list;
|
|
|
1860
|
|
|
1861 /* Global symbols are symbols of global scope. Currently we only use
|
|
|
1862 this to detect collisions already when parsing.
|
|
|
1863 TODO: Extend to verify procedure calls. */
|
|
|
1864
|
|
|
1865 enum gfc_symbol_type
|
|
|
1866 {
|
|
|
1867 GSYM_UNKNOWN=1, GSYM_PROGRAM, GSYM_FUNCTION, GSYM_SUBROUTINE,
|
|
|
1868 GSYM_MODULE, GSYM_COMMON, GSYM_BLOCK_DATA
|
|
|
1869 };
|
|
|
1870
|
|
|
1871 typedef struct gfc_gsymbol
|
|
|
1872 {
|
|
|
1873 BBT_HEADER(gfc_gsymbol);
|
|
|
1874
|
|
|
1875 const char *name;
|
|
|
1876 const char *sym_name;
|
|
|
1877 const char *mod_name;
|
|
|
1878 const char *binding_label;
|
|
|
1879 enum gfc_symbol_type type;
|
|
|
1880
|
|
|
1881 int defined, used;
|
|
|
1882 locus where;
|
|
|
1883 gfc_namespace *ns;
|
|
|
1884 }
|
|
|
1885 gfc_gsymbol;
|
|
|
1886
|
|
|
1887 extern gfc_gsymbol *gfc_gsym_root;
|
|
|
1888
|
|
|
1889 /* Information on interfaces being built. */
|
|
|
1890 typedef struct
|
|
|
1891 {
|
|
|
1892 interface_type type;
|
|
|
1893 gfc_symbol *sym;
|
|
|
1894 gfc_namespace *ns;
|
|
|
1895 gfc_user_op *uop;
|
|
|
1896 gfc_intrinsic_op op;
|
|
|
1897 }
|
|
|
1898 gfc_interface_info;
|
|
|
1899
|
|
|
1900 extern gfc_interface_info current_interface;
|
|
|
1901
|
|
|
1902
|
|
|
1903 /* Array reference. */
|
|
|
1904
|
|
|
1905 enum gfc_array_ref_dimen_type
|
|
|
1906 {
|
|
|
1907 DIMEN_ELEMENT = 1, DIMEN_RANGE, DIMEN_VECTOR, DIMEN_STAR, DIMEN_THIS_IMAGE, DIMEN_UNKNOWN
|
|
|
1908 };
|
|
|
1909
|
|
|
1910 typedef struct gfc_array_ref
|
|
|
1911 {
|
|
|
1912 ar_type type;
|
|
|
1913 int dimen; /* # of components in the reference */
|
|
|
1914 int codimen;
|
|
|
1915 bool in_allocate; /* For coarray checks. */
|
|
131
|
1916 gfc_expr *team;
|
|
111
|
1917 gfc_expr *stat;
|
|
|
1918 locus where;
|
|
|
1919 gfc_array_spec *as;
|
|
|
1920
|
|
|
1921 locus c_where[GFC_MAX_DIMENSIONS]; /* All expressions can be NULL */
|
|
|
1922 struct gfc_expr *start[GFC_MAX_DIMENSIONS], *end[GFC_MAX_DIMENSIONS],
|
|
|
1923 *stride[GFC_MAX_DIMENSIONS];
|
|
|
1924
|
|
|
1925 enum gfc_array_ref_dimen_type dimen_type[GFC_MAX_DIMENSIONS];
|
|
|
1926 }
|
|
|
1927 gfc_array_ref;
|
|
|
1928
|
|
|
1929 #define gfc_get_array_ref() XCNEW (gfc_array_ref)
|
|
|
1930
|
|
|
1931
|
|
|
1932 /* Component reference nodes. A variable is stored as an expression
|
|
|
1933 node that points to the base symbol. After that, a singly linked
|
|
|
1934 list of component reference nodes gives the variable's complete
|
|
|
1935 resolution. The array_ref component may be present and comes
|
|
|
1936 before the component component. */
|
|
|
1937
|
|
|
1938 enum ref_type
|
|
|
1939 { REF_ARRAY, REF_COMPONENT, REF_SUBSTRING };
|
|
|
1940
|
|
|
1941 typedef struct gfc_ref
|
|
|
1942 {
|
|
|
1943 ref_type type;
|
|
|
1944
|
|
|
1945 union
|
|
|
1946 {
|
|
|
1947 struct gfc_array_ref ar;
|
|
|
1948
|
|
|
1949 struct
|
|
|
1950 {
|
|
|
1951 gfc_component *component;
|
|
|
1952 gfc_symbol *sym;
|
|
|
1953 }
|
|
|
1954 c;
|
|
|
1955
|
|
|
1956 struct
|
|
|
1957 {
|
|
|
1958 struct gfc_expr *start, *end; /* Substring */
|
|
|
1959 gfc_charlen *length;
|
|
|
1960 }
|
|
|
1961 ss;
|
|
|
1962
|
|
|
1963 }
|
|
|
1964 u;
|
|
|
1965
|
|
|
1966 struct gfc_ref *next;
|
|
|
1967 }
|
|
|
1968 gfc_ref;
|
|
|
1969
|
|
|
1970 #define gfc_get_ref() XCNEW (gfc_ref)
|
|
|
1971
|
|
|
1972
|
|
|
1973 /* Structures representing intrinsic symbols and their arguments lists. */
|
|
|
1974 typedef struct gfc_intrinsic_arg
|
|
|
1975 {
|
|
|
1976 char name[GFC_MAX_SYMBOL_LEN + 1];
|
|
|
1977
|
|
|
1978 gfc_typespec ts;
|
|
|
1979 unsigned optional:1, value:1;
|
|
|
1980 ENUM_BITFIELD (sym_intent) intent:2;
|
|
|
1981 gfc_actual_arglist *actual;
|
|
|
1982
|
|
|
1983 struct gfc_intrinsic_arg *next;
|
|
|
1984
|
|
|
1985 }
|
|
|
1986 gfc_intrinsic_arg;
|
|
|
1987
|
|
|
1988
|
|
|
1989 /* Specifies the various kinds of check functions used to verify the
|
|
|
1990 argument lists of intrinsic functions. fX with X an integer refer
|
|
|
1991 to check functions of intrinsics with X arguments. f1m is used for
|
|
|
1992 the MAX and MIN intrinsics which can have an arbitrary number of
|
|
131
|
1993 arguments, f4ml is used for the MINLOC and MAXLOC intrinsics as
|
|
111
|
1994 these have special semantics. */
|
|
|
1995
|
|
|
1996 typedef union
|
|
|
1997 {
|
|
|
1998 bool (*f0)(void);
|
|
|
1999 bool (*f1)(struct gfc_expr *);
|
|
|
2000 bool (*f1m)(gfc_actual_arglist *);
|
|
|
2001 bool (*f2)(struct gfc_expr *, struct gfc_expr *);
|
|
|
2002 bool (*f3)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
|
|
131
|
2003 bool (*f5ml)(gfc_actual_arglist *);
|
|
111
|
2004 bool (*f3red)(gfc_actual_arglist *);
|
|
|
2005 bool (*f4)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
|
|
|
2006 struct gfc_expr *);
|
|
|
2007 bool (*f5)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
|
|
|
2008 struct gfc_expr *, struct gfc_expr *);
|
|
|
2009 }
|
|
|
2010 gfc_check_f;
|
|
|
2011
|
|
|
2012 /* Like gfc_check_f, these specify the type of the simplification
|
|
|
2013 function associated with an intrinsic. The fX are just like in
|
|
|
2014 gfc_check_f. cc is used for type conversion functions. */
|
|
|
2015
|
|
|
2016 typedef union
|
|
|
2017 {
|
|
|
2018 struct gfc_expr *(*f0)(void);
|
|
|
2019 struct gfc_expr *(*f1)(struct gfc_expr *);
|
|
|
2020 struct gfc_expr *(*f2)(struct gfc_expr *, struct gfc_expr *);
|
|
|
2021 struct gfc_expr *(*f3)(struct gfc_expr *, struct gfc_expr *,
|
|
|
2022 struct gfc_expr *);
|
|
|
2023 struct gfc_expr *(*f4)(struct gfc_expr *, struct gfc_expr *,
|
|
|
2024 struct gfc_expr *, struct gfc_expr *);
|
|
|
2025 struct gfc_expr *(*f5)(struct gfc_expr *, struct gfc_expr *,
|
|
|
2026 struct gfc_expr *, struct gfc_expr *,
|
|
|
2027 struct gfc_expr *);
|
|
|
2028 struct gfc_expr *(*cc)(struct gfc_expr *, bt, int);
|
|
|
2029 }
|
|
|
2030 gfc_simplify_f;
|
|
|
2031
|
|
|
2032 /* Again like gfc_check_f, these specify the type of the resolution
|
|
|
2033 function associated with an intrinsic. The fX are just like in
|
|
|
2034 gfc_check_f. f1m is used for MIN and MAX, s1 is used for abort(). */
|
|
|
2035
|
|
|
2036 typedef union
|
|
|
2037 {
|
|
|
2038 void (*f0)(struct gfc_expr *);
|
|
|
2039 void (*f1)(struct gfc_expr *, struct gfc_expr *);
|
|
|
2040 void (*f1m)(struct gfc_expr *, struct gfc_actual_arglist *);
|
|
|
2041 void (*f2)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
|
|
|
2042 void (*f3)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
|
|
|
2043 struct gfc_expr *);
|
|
|
2044 void (*f4)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
|
|
|
2045 struct gfc_expr *, struct gfc_expr *);
|
|
|
2046 void (*f5)(struct gfc_expr *, struct gfc_expr *, struct gfc_expr *,
|
|
|
2047 struct gfc_expr *, struct gfc_expr *, struct gfc_expr *);
|
|
|
2048 void (*s1)(struct gfc_code *);
|
|
|
2049 }
|
|
|
2050 gfc_resolve_f;
|
|
|
2051
|
|
|
2052
|
|
|
2053 typedef struct gfc_intrinsic_sym
|
|
|
2054 {
|
|
|
2055 const char *name, *lib_name;
|
|
|
2056 gfc_intrinsic_arg *formal;
|
|
|
2057 gfc_typespec ts;
|
|
|
2058 unsigned elemental:1, inquiry:1, transformational:1, pure:1,
|
|
|
2059 generic:1, specific:1, actual_ok:1, noreturn:1, conversion:1,
|
|
|
2060 from_module:1, vararg:1;
|
|
|
2061
|
|
|
2062 int standard;
|
|
|
2063
|
|
|
2064 gfc_simplify_f simplify;
|
|
|
2065 gfc_check_f check;
|
|
|
2066 gfc_resolve_f resolve;
|
|
|
2067 struct gfc_intrinsic_sym *specific_head, *next;
|
|
|
2068 gfc_isym_id id;
|
|
|
2069
|
|
|
2070 }
|
|
|
2071 gfc_intrinsic_sym;
|
|
|
2072
|
|
|
2073
|
|
|
2074 /* Expression nodes. The expression node types deserve explanations,
|
|
|
2075 since the last couple can be easily misconstrued:
|
|
|
2076
|
|
|
2077 EXPR_OP Operator node pointing to one or two other nodes
|
|
|
2078 EXPR_FUNCTION Function call, symbol points to function's name
|
|
|
2079 EXPR_CONSTANT A scalar constant: Logical, String, Real, Int or Complex
|
|
|
2080 EXPR_VARIABLE An Lvalue with a root symbol and possible reference list
|
|
|
2081 which expresses structure, array and substring refs.
|
|
|
2082 EXPR_NULL The NULL pointer value (which also has a basic type).
|
|
|
2083 EXPR_SUBSTRING A substring of a constant string
|
|
|
2084 EXPR_STRUCTURE A structure constructor
|
|
|
2085 EXPR_ARRAY An array constructor.
|
|
|
2086 EXPR_COMPCALL Function (or subroutine) call of a procedure pointer
|
|
|
2087 component or type-bound procedure. */
|
|
|
2088
|
|
|
2089 #include <mpfr.h>
|
|
|
2090 #include <mpc.h>
|
|
|
2091 #define GFC_RND_MODE GMP_RNDN
|
|
|
2092 #define GFC_MPC_RND_MODE MPC_RNDNN
|
|
|
2093
|
|
|
2094 typedef splay_tree gfc_constructor_base;
|
|
|
2095
|
|
131
|
2096
|
|
|
2097 /* This should be an unsigned variable of type size_t. But to handle
|
|
|
2098 compiling to a 64-bit target from a 32-bit host, we need to use a
|
|
|
2099 HOST_WIDE_INT. Also, occasionally the string length field is used
|
|
|
2100 as a flag with values -1 and -2, see e.g. gfc_add_assign_aux_vars.
|
|
|
2101 So it needs to be signed. */
|
|
|
2102 typedef HOST_WIDE_INT gfc_charlen_t;
|
|
|
2103
|
|
111
|
2104 typedef struct gfc_expr
|
|
|
2105 {
|
|
|
2106 expr_t expr_type;
|
|
|
2107
|
|
|
2108 gfc_typespec ts; /* These two refer to the overall expression */
|
|
|
2109
|
|
|
2110 int rank; /* 0 indicates a scalar, -1 an assumed-rank array. */
|
|
|
2111 mpz_t *shape; /* Can be NULL if shape is unknown at compile time */
|
|
|
2112
|
|
|
2113 /* Nonnull for functions and structure constructors, may also used to hold the
|
|
|
2114 base-object for component calls. */
|
|
|
2115 gfc_symtree *symtree;
|
|
|
2116
|
|
|
2117 gfc_ref *ref;
|
|
|
2118
|
|
|
2119 locus where;
|
|
|
2120
|
|
|
2121 /* Used to store the base expression in component calls, when the expression
|
|
|
2122 is not a variable. */
|
|
|
2123 struct gfc_expr *base_expr;
|
|
|
2124
|
|
|
2125 /* is_boz is true if the integer is regarded as BOZ bit pattern and is_snan
|
|
|
2126 denotes a signalling not-a-number. */
|
|
|
2127 unsigned int is_boz : 1, is_snan : 1;
|
|
|
2128
|
|
|
2129 /* Sometimes, when an error has been emitted, it is necessary to prevent
|
|
|
2130 it from recurring. */
|
|
|
2131 unsigned int error : 1;
|
|
|
2132
|
|
|
2133 /* Mark an expression where a user operator has been substituted by
|
|
|
2134 a function call in interface.c(gfc_extend_expr). */
|
|
|
2135 unsigned int user_operator : 1;
|
|
|
2136
|
|
|
2137 /* Mark an expression as being a MOLD argument of ALLOCATE. */
|
|
|
2138 unsigned int mold : 1;
|
|
|
2139
|
|
|
2140 /* Will require finalization after use. */
|
|
|
2141 unsigned int must_finalize : 1;
|
|
|
2142
|
|
131
|
2143 /* Set this if no range check should be performed on this expression. */
|
|
|
2144
|
|
|
2145 unsigned int no_bounds_check : 1;
|
|
|
2146
|
|
|
2147 /* Set this if a matmul expression has already been evaluated for conversion
|
|
|
2148 to a BLAS call. */
|
|
|
2149
|
|
|
2150 unsigned int external_blas : 1;
|
|
|
2151
|
|
111
|
2152 /* If an expression comes from a Hollerith constant or compile-time
|
|
|
2153 evaluation of a transfer statement, it may have a prescribed target-
|
|
|
2154 memory representation, and these cannot always be backformed from
|
|
|
2155 the value. */
|
|
|
2156 struct
|
|
|
2157 {
|
|
131
|
2158 gfc_charlen_t length;
|
|
111
|
2159 char *string;
|
|
|
2160 }
|
|
|
2161 representation;
|
|
|
2162
|
|
|
2163 union
|
|
|
2164 {
|
|
|
2165 int logical;
|
|
|
2166
|
|
|
2167 io_kind iokind;
|
|
|
2168
|
|
|
2169 mpz_t integer;
|
|
|
2170
|
|
|
2171 mpfr_t real;
|
|
|
2172
|
|
|
2173 mpc_t complex;
|
|
|
2174
|
|
|
2175 struct
|
|
|
2176 {
|
|
|
2177 gfc_intrinsic_op op;
|
|
|
2178 gfc_user_op *uop;
|
|
|
2179 struct gfc_expr *op1, *op2;
|
|
|
2180 }
|
|
|
2181 op;
|
|
|
2182
|
|
|
2183 struct
|
|
|
2184 {
|
|
|
2185 gfc_actual_arglist *actual;
|
|
|
2186 const char *name; /* Points to the ultimate name of the function */
|
|
|
2187 gfc_intrinsic_sym *isym;
|
|
|
2188 gfc_symbol *esym;
|
|
|
2189 }
|
|
|
2190 function;
|
|
|
2191
|
|
|
2192 struct
|
|
|
2193 {
|
|
|
2194 gfc_actual_arglist* actual;
|
|
|
2195 const char* name;
|
|
|
2196 /* Base-object, whose component was called. NULL means that it should
|
|
|
2197 be taken from symtree/ref. */
|
|
|
2198 struct gfc_expr* base_object;
|
|
|
2199 gfc_typebound_proc* tbp; /* Should overlap with esym. */
|
|
|
2200
|
|
|
2201 /* For type-bound operators, we want to call PASS procedures but already
|
|
|
2202 have the full arglist; mark this, so that it is not extended by the
|
|
|
2203 PASS argument. */
|
|
|
2204 unsigned ignore_pass:1;
|
|
|
2205
|
|
|
2206 /* Do assign-calls rather than calls, that is appropriate dependency
|
|
|
2207 checking. */
|
|
|
2208 unsigned assign:1;
|
|
|
2209 }
|
|
|
2210 compcall;
|
|
|
2211
|
|
|
2212 struct
|
|
|
2213 {
|
|
131
|
2214 gfc_charlen_t length;
|
|
111
|
2215 gfc_char_t *string;
|
|
|
2216 }
|
|
|
2217 character;
|
|
|
2218
|
|
|
2219 gfc_constructor_base constructor;
|
|
|
2220 }
|
|
|
2221 value;
|
|
|
2222
|
|
|
2223 /* Used to store PDT expression lists associated with expressions. */
|
|
|
2224 gfc_actual_arglist *param_list;
|
|
|
2225
|
|
|
2226 }
|
|
|
2227 gfc_expr;
|
|
|
2228
|
|
|
2229
|
|
|
2230 #define gfc_get_shape(rank) (XCNEWVEC (mpz_t, (rank)))
|
|
|
2231
|
|
|
2232 /* Structures for information associated with different kinds of
|
|
|
2233 numbers. The first set of integer parameters define all there is
|
|
|
2234 to know about a particular kind. The rest of the elements are
|
|
|
2235 computed from the first elements. */
|
|
|
2236
|
|
|
2237 typedef struct
|
|
|
2238 {
|
|
|
2239 /* Values really representable by the target. */
|
|
|
2240 mpz_t huge, pedantic_min_int, min_int;
|
|
|
2241
|
|
|
2242 int kind, radix, digits, bit_size, range;
|
|
|
2243
|
|
|
2244 /* True if the C type of the given name maps to this precision.
|
|
|
2245 Note that more than one bit can be set. */
|
|
|
2246 unsigned int c_char : 1;
|
|
|
2247 unsigned int c_short : 1;
|
|
|
2248 unsigned int c_int : 1;
|
|
|
2249 unsigned int c_long : 1;
|
|
|
2250 unsigned int c_long_long : 1;
|
|
|
2251 }
|
|
|
2252 gfc_integer_info;
|
|
|
2253
|
|
|
2254 extern gfc_integer_info gfc_integer_kinds[];
|
|
|
2255
|
|
|
2256
|
|
|
2257 typedef struct
|
|
|
2258 {
|
|
|
2259 int kind, bit_size;
|
|
|
2260
|
|
|
2261 /* True if the C++ type bool, C99 type _Bool, maps to this precision. */
|
|
|
2262 unsigned int c_bool : 1;
|
|
|
2263 }
|
|
|
2264 gfc_logical_info;
|
|
|
2265
|
|
|
2266 extern gfc_logical_info gfc_logical_kinds[];
|
|
|
2267
|
|
|
2268
|
|
|
2269 typedef struct
|
|
|
2270 {
|
|
|
2271 mpfr_t epsilon, huge, tiny, subnormal;
|
|
|
2272 int kind, radix, digits, min_exponent, max_exponent;
|
|
|
2273 int range, precision;
|
|
|
2274
|
|
|
2275 /* The precision of the type as reported by GET_MODE_PRECISION. */
|
|
|
2276 int mode_precision;
|
|
|
2277
|
|
|
2278 /* True if the C type of the given name maps to this precision.
|
|
|
2279 Note that more than one bit can be set. */
|
|
|
2280 unsigned int c_float : 1;
|
|
|
2281 unsigned int c_double : 1;
|
|
|
2282 unsigned int c_long_double : 1;
|
|
|
2283 unsigned int c_float128 : 1;
|
|
|
2284 }
|
|
|
2285 gfc_real_info;
|
|
|
2286
|
|
|
2287 extern gfc_real_info gfc_real_kinds[];
|
|
|
2288
|
|
|
2289 typedef struct
|
|
|
2290 {
|
|
|
2291 int kind, bit_size;
|
|
|
2292 const char *name;
|
|
|
2293 }
|
|
|
2294 gfc_character_info;
|
|
|
2295
|
|
|
2296 extern gfc_character_info gfc_character_kinds[];
|
|
|
2297
|
|
|
2298
|
|
|
2299 /* Equivalence structures. Equivalent lvalues are linked along the
|
|
|
2300 *eq pointer, equivalence sets are strung along the *next node. */
|
|
|
2301 typedef struct gfc_equiv
|
|
|
2302 {
|
|
|
2303 struct gfc_equiv *next, *eq;
|
|
|
2304 gfc_expr *expr;
|
|
|
2305 const char *module;
|
|
|
2306 int used;
|
|
|
2307 }
|
|
|
2308 gfc_equiv;
|
|
|
2309
|
|
|
2310 #define gfc_get_equiv() XCNEW (gfc_equiv)
|
|
|
2311
|
|
|
2312 /* Holds a single equivalence member after processing. */
|
|
|
2313 typedef struct gfc_equiv_info
|
|
|
2314 {
|
|
|
2315 gfc_symbol *sym;
|
|
|
2316 HOST_WIDE_INT offset;
|
|
|
2317 HOST_WIDE_INT length;
|
|
|
2318 struct gfc_equiv_info *next;
|
|
|
2319 } gfc_equiv_info;
|
|
|
2320
|
|
|
2321 /* Holds equivalence groups, after they have been processed. */
|
|
|
2322 typedef struct gfc_equiv_list
|
|
|
2323 {
|
|
|
2324 gfc_equiv_info *equiv;
|
|
|
2325 struct gfc_equiv_list *next;
|
|
|
2326 } gfc_equiv_list;
|
|
|
2327
|
|
|
2328 /* gfc_case stores the selector list of a case statement. The *low
|
|
|
2329 and *high pointers can point to the same expression in the case of
|
|
|
2330 a single value. If *high is NULL, the selection is from *low
|
|
|
2331 upwards, if *low is NULL the selection is *high downwards.
|
|
|
2332
|
|
|
2333 This structure has separate fields to allow single and double linked
|
|
|
2334 lists of CASEs at the same time. The singe linked list along the NEXT
|
|
|
2335 field is a list of cases for a single CASE label. The double linked
|
|
|
2336 list along the LEFT/RIGHT fields is used to detect overlap and to
|
|
|
2337 build a table of the cases for SELECT constructs with a CHARACTER
|
|
|
2338 case expression. */
|
|
|
2339
|
|
|
2340 typedef struct gfc_case
|
|
|
2341 {
|
|
|
2342 /* Where we saw this case. */
|
|
|
2343 locus where;
|
|
|
2344 int n;
|
|
|
2345
|
|
|
2346 /* Case range values. If (low == high), it's a single value. If one of
|
|
|
2347 the labels is NULL, it's an unbounded case. If both are NULL, this
|
|
|
2348 represents the default case. */
|
|
|
2349 gfc_expr *low, *high;
|
|
|
2350
|
|
|
2351 /* Only used for SELECT TYPE. */
|
|
|
2352 gfc_typespec ts;
|
|
|
2353
|
|
|
2354 /* Next case label in the list of cases for a single CASE label. */
|
|
|
2355 struct gfc_case *next;
|
|
|
2356
|
|
|
2357 /* Used for detecting overlap, and for code generation. */
|
|
|
2358 struct gfc_case *left, *right;
|
|
|
2359
|
|
|
2360 /* True if this case label can never be matched. */
|
|
|
2361 int unreachable;
|
|
|
2362 }
|
|
|
2363 gfc_case;
|
|
|
2364
|
|
|
2365 #define gfc_get_case() XCNEW (gfc_case)
|
|
|
2366
|
|
|
2367
|
|
|
2368 typedef struct
|
|
|
2369 {
|
|
|
2370 gfc_expr *var, *start, *end, *step;
|
|
131
|
2371 unsigned short unroll;
|
|
111
|
2372 }
|
|
|
2373 gfc_iterator;
|
|
|
2374
|
|
|
2375 #define gfc_get_iterator() XCNEW (gfc_iterator)
|
|
|
2376
|
|
|
2377
|
|
|
2378 /* Allocation structure for ALLOCATE, DEALLOCATE and NULLIFY statements. */
|
|
|
2379
|
|
|
2380 typedef struct gfc_alloc
|
|
|
2381 {
|
|
|
2382 gfc_expr *expr;
|
|
|
2383 struct gfc_alloc *next;
|
|
|
2384 }
|
|
|
2385 gfc_alloc;
|
|
|
2386
|
|
|
2387 #define gfc_get_alloc() XCNEW (gfc_alloc)
|
|
|
2388
|
|
|
2389
|
|
|
2390 typedef struct
|
|
|
2391 {
|
|
|
2392 gfc_expr *unit, *file, *status, *access, *form, *recl,
|
|
|
2393 *blank, *position, *action, *delim, *pad, *iostat, *iomsg, *convert,
|
|
|
2394 *decimal, *encoding, *round, *sign, *asynchronous, *id, *newunit,
|
|
|
2395 *share, *cc;
|
|
|
2396 char readonly;
|
|
|
2397 gfc_st_label *err;
|
|
|
2398 }
|
|
|
2399 gfc_open;
|
|
|
2400
|
|
|
2401
|
|
|
2402 typedef struct
|
|
|
2403 {
|
|
|
2404 gfc_expr *unit, *status, *iostat, *iomsg;
|
|
|
2405 gfc_st_label *err;
|
|
|
2406 }
|
|
|
2407 gfc_close;
|
|
|
2408
|
|
|
2409
|
|
|
2410 typedef struct
|
|
|
2411 {
|
|
|
2412 gfc_expr *unit, *iostat, *iomsg;
|
|
|
2413 gfc_st_label *err;
|
|
|
2414 }
|
|
|
2415 gfc_filepos;
|
|
|
2416
|
|
|
2417
|
|
|
2418 typedef struct
|
|
|
2419 {
|
|
|
2420 gfc_expr *unit, *file, *iostat, *exist, *opened, *number, *named,
|
|
|
2421 *name, *access, *sequential, *direct, *form, *formatted,
|
|
|
2422 *unformatted, *recl, *nextrec, *blank, *position, *action, *read,
|
|
|
2423 *write, *readwrite, *delim, *pad, *iolength, *iomsg, *convert, *strm_pos,
|
|
|
2424 *asynchronous, *decimal, *encoding, *pending, *round, *sign, *size, *id,
|
|
|
2425 *iqstream, *share, *cc;
|
|
|
2426
|
|
|
2427 gfc_st_label *err;
|
|
|
2428
|
|
|
2429 }
|
|
|
2430 gfc_inquire;
|
|
|
2431
|
|
|
2432
|
|
|
2433 typedef struct
|
|
|
2434 {
|
|
|
2435 gfc_expr *unit, *iostat, *iomsg, *id;
|
|
|
2436 gfc_st_label *err, *end, *eor;
|
|
|
2437 }
|
|
|
2438 gfc_wait;
|
|
|
2439
|
|
|
2440
|
|
|
2441 typedef struct
|
|
|
2442 {
|
|
|
2443 gfc_expr *io_unit, *format_expr, *rec, *advance, *iostat, *size, *iomsg,
|
|
|
2444 *id, *pos, *asynchronous, *blank, *decimal, *delim, *pad, *round,
|
|
|
2445 *sign, *extra_comma, *dt_io_kind, *udtio;
|
|
131
|
2446 char dec_ext;
|
|
111
|
2447
|
|
|
2448 gfc_symbol *namelist;
|
|
|
2449 /* A format_label of `format_asterisk' indicates the "*" format */
|
|
|
2450 gfc_st_label *format_label;
|
|
|
2451 gfc_st_label *err, *end, *eor;
|
|
|
2452
|
|
|
2453 locus eor_where, end_where, err_where;
|
|
|
2454 }
|
|
|
2455 gfc_dt;
|
|
|
2456
|
|
|
2457
|
|
|
2458 typedef struct gfc_forall_iterator
|
|
|
2459 {
|
|
|
2460 gfc_expr *var, *start, *end, *stride;
|
|
|
2461 struct gfc_forall_iterator *next;
|
|
|
2462 }
|
|
|
2463 gfc_forall_iterator;
|
|
|
2464
|
|
|
2465
|
|
|
2466 /* Linked list to store associations in an ASSOCIATE statement. */
|
|
|
2467
|
|
|
2468 typedef struct gfc_association_list
|
|
|
2469 {
|
|
|
2470 struct gfc_association_list *next;
|
|
|
2471
|
|
|
2472 /* Whether this is association to a variable that can be changed; otherwise,
|
|
|
2473 it's association to an expression and the name may not be used as
|
|
|
2474 lvalue. */
|
|
|
2475 unsigned variable:1;
|
|
|
2476
|
|
|
2477 /* True if this struct is currently only linked to from a gfc_symbol rather
|
|
|
2478 than as part of a real list in gfc_code->ext.block.assoc. This may
|
|
|
2479 happen for SELECT TYPE temporaries and must be considered
|
|
|
2480 for memory handling. */
|
|
|
2481 unsigned dangling:1;
|
|
|
2482
|
|
|
2483 /* True when the rank of the target expression is guessed during parsing. */
|
|
|
2484 unsigned rankguessed:1;
|
|
|
2485
|
|
|
2486 char name[GFC_MAX_SYMBOL_LEN + 1];
|
|
|
2487 gfc_symtree *st; /* Symtree corresponding to name. */
|
|
|
2488 locus where;
|
|
|
2489
|
|
|
2490 gfc_expr *target;
|
|
|
2491 }
|
|
|
2492 gfc_association_list;
|
|
|
2493 #define gfc_get_association_list() XCNEW (gfc_association_list)
|
|
|
2494
|
|
|
2495
|
|
|
2496 /* Executable statements that fill gfc_code structures. */
|
|
|
2497 enum gfc_exec_op
|
|
|
2498 {
|
|
|
2499 EXEC_NOP = 1, EXEC_END_NESTED_BLOCK, EXEC_END_BLOCK, EXEC_ASSIGN,
|
|
|
2500 EXEC_LABEL_ASSIGN, EXEC_POINTER_ASSIGN, EXEC_CRITICAL, EXEC_ERROR_STOP,
|
|
|
2501 EXEC_GOTO, EXEC_CALL, EXEC_COMPCALL, EXEC_ASSIGN_CALL, EXEC_RETURN,
|
|
|
2502 EXEC_ENTRY, EXEC_PAUSE, EXEC_STOP, EXEC_CONTINUE, EXEC_INIT_ASSIGN,
|
|
|
2503 EXEC_IF, EXEC_ARITHMETIC_IF, EXEC_DO, EXEC_DO_CONCURRENT, EXEC_DO_WHILE,
|
|
|
2504 EXEC_SELECT, EXEC_BLOCK, EXEC_FORALL, EXEC_WHERE, EXEC_CYCLE, EXEC_EXIT,
|
|
|
2505 EXEC_CALL_PPC, EXEC_ALLOCATE, EXEC_DEALLOCATE, EXEC_END_PROCEDURE,
|
|
|
2506 EXEC_SELECT_TYPE, EXEC_SYNC_ALL, EXEC_SYNC_MEMORY, EXEC_SYNC_IMAGES,
|
|
|
2507 EXEC_OPEN, EXEC_CLOSE, EXEC_WAIT,
|
|
|
2508 EXEC_READ, EXEC_WRITE, EXEC_IOLENGTH, EXEC_TRANSFER, EXEC_DT_END,
|
|
|
2509 EXEC_BACKSPACE, EXEC_ENDFILE, EXEC_INQUIRE, EXEC_REWIND, EXEC_FLUSH,
|
|
131
|
2510 EXEC_FORM_TEAM, EXEC_CHANGE_TEAM, EXEC_END_TEAM, EXEC_SYNC_TEAM,
|
|
111
|
2511 EXEC_LOCK, EXEC_UNLOCK, EXEC_EVENT_POST, EXEC_EVENT_WAIT, EXEC_FAIL_IMAGE,
|
|
|
2512 EXEC_OACC_KERNELS_LOOP, EXEC_OACC_PARALLEL_LOOP, EXEC_OACC_ROUTINE,
|
|
|
2513 EXEC_OACC_PARALLEL, EXEC_OACC_KERNELS, EXEC_OACC_DATA, EXEC_OACC_HOST_DATA,
|
|
|
2514 EXEC_OACC_LOOP, EXEC_OACC_UPDATE, EXEC_OACC_WAIT, EXEC_OACC_CACHE,
|
|
|
2515 EXEC_OACC_ENTER_DATA, EXEC_OACC_EXIT_DATA, EXEC_OACC_ATOMIC,
|
|
|
2516 EXEC_OACC_DECLARE,
|
|
|
2517 EXEC_OMP_CRITICAL, EXEC_OMP_DO, EXEC_OMP_FLUSH, EXEC_OMP_MASTER,
|
|
|
2518 EXEC_OMP_ORDERED, EXEC_OMP_PARALLEL, EXEC_OMP_PARALLEL_DO,
|
|
|
2519 EXEC_OMP_PARALLEL_SECTIONS, EXEC_OMP_PARALLEL_WORKSHARE,
|
|
|
2520 EXEC_OMP_SECTIONS, EXEC_OMP_SINGLE, EXEC_OMP_WORKSHARE,
|
|
|
2521 EXEC_OMP_ATOMIC, EXEC_OMP_BARRIER, EXEC_OMP_END_NOWAIT,
|
|
|
2522 EXEC_OMP_END_SINGLE, EXEC_OMP_TASK, EXEC_OMP_TASKWAIT,
|
|
|
2523 EXEC_OMP_TASKYIELD, EXEC_OMP_CANCEL, EXEC_OMP_CANCELLATION_POINT,
|
|
|
2524 EXEC_OMP_TASKGROUP, EXEC_OMP_SIMD, EXEC_OMP_DO_SIMD,
|
|
|
2525 EXEC_OMP_PARALLEL_DO_SIMD, EXEC_OMP_TARGET, EXEC_OMP_TARGET_DATA,
|
|
|
2526 EXEC_OMP_TEAMS, EXEC_OMP_DISTRIBUTE, EXEC_OMP_DISTRIBUTE_SIMD,
|
|
|
2527 EXEC_OMP_DISTRIBUTE_PARALLEL_DO, EXEC_OMP_DISTRIBUTE_PARALLEL_DO_SIMD,
|
|
|
2528 EXEC_OMP_TARGET_TEAMS, EXEC_OMP_TEAMS_DISTRIBUTE,
|
|
|
2529 EXEC_OMP_TEAMS_DISTRIBUTE_SIMD, EXEC_OMP_TARGET_TEAMS_DISTRIBUTE,
|
|
|
2530 EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD,
|
|
|
2531 EXEC_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO,
|
|
|
2532 EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO,
|
|
|
2533 EXEC_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
|
|
|
2534 EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD,
|
|
|
2535 EXEC_OMP_TARGET_UPDATE, EXEC_OMP_END_CRITICAL,
|
|
|
2536 EXEC_OMP_TARGET_ENTER_DATA, EXEC_OMP_TARGET_EXIT_DATA,
|
|
|
2537 EXEC_OMP_TARGET_PARALLEL, EXEC_OMP_TARGET_PARALLEL_DO,
|
|
|
2538 EXEC_OMP_TARGET_PARALLEL_DO_SIMD, EXEC_OMP_TARGET_SIMD,
|
|
|
2539 EXEC_OMP_TASKLOOP, EXEC_OMP_TASKLOOP_SIMD
|
|
|
2540 };
|
|
|
2541
|
|
|
2542 enum gfc_omp_atomic_op
|
|
|
2543 {
|
|
|
2544 GFC_OMP_ATOMIC_UPDATE = 0,
|
|
|
2545 GFC_OMP_ATOMIC_READ = 1,
|
|
|
2546 GFC_OMP_ATOMIC_WRITE = 2,
|
|
|
2547 GFC_OMP_ATOMIC_CAPTURE = 3,
|
|
|
2548 GFC_OMP_ATOMIC_MASK = 3,
|
|
|
2549 GFC_OMP_ATOMIC_SEQ_CST = 4,
|
|
|
2550 GFC_OMP_ATOMIC_SWAP = 8
|
|
|
2551 };
|
|
|
2552
|
|
|
2553 typedef struct gfc_code
|
|
|
2554 {
|
|
|
2555 gfc_exec_op op;
|
|
|
2556
|
|
|
2557 struct gfc_code *block, *next;
|
|
|
2558 locus loc;
|
|
|
2559
|
|
|
2560 gfc_st_label *here, *label1, *label2, *label3;
|
|
|
2561 gfc_symtree *symtree;
|
|
|
2562 gfc_expr *expr1, *expr2, *expr3, *expr4;
|
|
|
2563 /* A name isn't sufficient to identify a subroutine, we need the actual
|
|
|
2564 symbol for the interface definition.
|
|
|
2565 const char *sub_name; */
|
|
|
2566 gfc_symbol *resolved_sym;
|
|
|
2567 gfc_intrinsic_sym *resolved_isym;
|
|
|
2568
|
|
|
2569 union
|
|
|
2570 {
|
|
|
2571 gfc_actual_arglist *actual;
|
|
|
2572 gfc_iterator *iterator;
|
|
|
2573
|
|
|
2574 struct
|
|
|
2575 {
|
|
|
2576 gfc_typespec ts;
|
|
|
2577 gfc_alloc *list;
|
|
|
2578 /* Take the array specification from expr3 to allocate arrays
|
|
|
2579 without an explicit array specification. */
|
|
|
2580 unsigned arr_spec_from_expr3:1;
|
|
|
2581 }
|
|
|
2582 alloc;
|
|
|
2583
|
|
|
2584 struct
|
|
|
2585 {
|
|
|
2586 gfc_namespace *ns;
|
|
|
2587 gfc_association_list *assoc;
|
|
|
2588 gfc_case *case_list;
|
|
|
2589 }
|
|
|
2590 block;
|
|
|
2591
|
|
|
2592 gfc_open *open;
|
|
|
2593 gfc_close *close;
|
|
|
2594 gfc_filepos *filepos;
|
|
|
2595 gfc_inquire *inquire;
|
|
|
2596 gfc_wait *wait;
|
|
|
2597 gfc_dt *dt;
|
|
|
2598 gfc_forall_iterator *forall_iterator;
|
|
|
2599 struct gfc_code *which_construct;
|
|
|
2600 int stop_code;
|
|
|
2601 gfc_entry_list *entry;
|
|
|
2602 gfc_oacc_declare *oacc_declare;
|
|
|
2603 gfc_omp_clauses *omp_clauses;
|
|
|
2604 const char *omp_name;
|
|
|
2605 gfc_omp_namelist *omp_namelist;
|
|
|
2606 bool omp_bool;
|
|
|
2607 gfc_omp_atomic_op omp_atomic;
|
|
|
2608 }
|
|
|
2609 ext; /* Points to additional structures required by statement */
|
|
|
2610
|
|
|
2611 /* Cycle and break labels in constructs. */
|
|
|
2612 tree cycle_label;
|
|
|
2613 tree exit_label;
|
|
|
2614 }
|
|
|
2615 gfc_code;
|
|
|
2616
|
|
|
2617
|
|
|
2618 /* Storage for DATA statements. */
|
|
|
2619 typedef struct gfc_data_variable
|
|
|
2620 {
|
|
|
2621 gfc_expr *expr;
|
|
|
2622 gfc_iterator iter;
|
|
|
2623 struct gfc_data_variable *list, *next;
|
|
|
2624 }
|
|
|
2625 gfc_data_variable;
|
|
|
2626
|
|
|
2627
|
|
|
2628 typedef struct gfc_data_value
|
|
|
2629 {
|
|
|
2630 mpz_t repeat;
|
|
|
2631 gfc_expr *expr;
|
|
|
2632 struct gfc_data_value *next;
|
|
|
2633 }
|
|
|
2634 gfc_data_value;
|
|
|
2635
|
|
|
2636
|
|
|
2637 typedef struct gfc_data
|
|
|
2638 {
|
|
|
2639 gfc_data_variable *var;
|
|
|
2640 gfc_data_value *value;
|
|
|
2641 locus where;
|
|
|
2642
|
|
|
2643 struct gfc_data *next;
|
|
|
2644 }
|
|
|
2645 gfc_data;
|
|
|
2646
|
|
|
2647
|
|
|
2648 /* Structure for holding compile options */
|
|
|
2649 typedef struct
|
|
|
2650 {
|
|
|
2651 char *module_dir;
|
|
|
2652 gfc_source_form source_form;
|
|
|
2653 int max_continue_fixed;
|
|
|
2654 int max_continue_free;
|
|
|
2655 int max_identifier_length;
|
|
|
2656
|
|
|
2657 int max_errors;
|
|
|
2658
|
|
|
2659 int flag_preprocessed;
|
|
|
2660 int flag_d_lines;
|
|
|
2661 int flag_init_integer;
|
|
|
2662 int flag_init_integer_value;
|
|
|
2663 int flag_init_logical;
|
|
|
2664 int flag_init_character;
|
|
|
2665 char flag_init_character_value;
|
|
|
2666
|
|
|
2667 int fpe;
|
|
|
2668 int fpe_summary;
|
|
|
2669 int rtcheck;
|
|
|
2670
|
|
|
2671 int warn_std;
|
|
|
2672 int allow_std;
|
|
|
2673 }
|
|
|
2674 gfc_option_t;
|
|
|
2675
|
|
|
2676 extern gfc_option_t gfc_option;
|
|
|
2677
|
|
|
2678 /* Constructor nodes for array and structure constructors. */
|
|
|
2679 typedef struct gfc_constructor
|
|
|
2680 {
|
|
|
2681 gfc_constructor_base base;
|
|
|
2682 mpz_t offset; /* Offset within a constructor, used as
|
|
|
2683 key within base. */
|
|
|
2684
|
|
|
2685 gfc_expr *expr;
|
|
|
2686 gfc_iterator *iterator;
|
|
|
2687 locus where;
|
|
|
2688
|
|
|
2689 union
|
|
|
2690 {
|
|
|
2691 gfc_component *component; /* Record the component being initialized. */
|
|
|
2692 }
|
|
|
2693 n;
|
|
|
2694 mpz_t repeat; /* Record the repeat number of initial values in data
|
|
|
2695 statement like "data a/5*10/". */
|
|
|
2696 }
|
|
|
2697 gfc_constructor;
|
|
|
2698
|
|
|
2699
|
|
|
2700 typedef struct iterator_stack
|
|
|
2701 {
|
|
|
2702 gfc_symtree *variable;
|
|
|
2703 mpz_t value;
|
|
|
2704 struct iterator_stack *prev;
|
|
|
2705 }
|
|
|
2706 iterator_stack;
|
|
|
2707 extern iterator_stack *iter_stack;
|
|
|
2708
|
|
|
2709
|
|
|
2710 /* Used for (possibly nested) SELECT TYPE statements. */
|
|
|
2711 typedef struct gfc_select_type_stack
|
|
|
2712 {
|
|
|
2713 gfc_symbol *selector; /* Current selector variable. */
|
|
|
2714 gfc_symtree *tmp; /* Current temporary variable. */
|
|
|
2715 struct gfc_select_type_stack *prev; /* Previous element on stack. */
|
|
|
2716 }
|
|
|
2717 gfc_select_type_stack;
|
|
|
2718 extern gfc_select_type_stack *select_type_stack;
|
|
|
2719 #define gfc_get_select_type_stack() XCNEW (gfc_select_type_stack)
|
|
|
2720
|
|
|
2721
|
|
|
2722 /* Node in the linked list used for storing finalizer procedures. */
|
|
|
2723
|
|
|
2724 typedef struct gfc_finalizer
|
|
|
2725 {
|
|
|
2726 struct gfc_finalizer* next;
|
|
|
2727 locus where; /* Where the FINAL declaration occurred. */
|
|
|
2728
|
|
|
2729 /* Up to resolution, we want the gfc_symbol, there we lookup the corresponding
|
|
|
2730 symtree and later need only that. This way, we can access and call the
|
|
|
2731 finalizers from every context as they should be "always accessible". I
|
|
|
2732 don't make this a union because we need the information whether proc_sym is
|
|
|
2733 still referenced or not for dereferencing it on deleting a gfc_finalizer
|
|
|
2734 structure. */
|
|
|
2735 gfc_symbol* proc_sym;
|
|
|
2736 gfc_symtree* proc_tree;
|
|
|
2737 }
|
|
|
2738 gfc_finalizer;
|
|
|
2739 #define gfc_get_finalizer() XCNEW (gfc_finalizer)
|
|
|
2740
|
|
|
2741
|
|
|
2742 /************************ Function prototypes *************************/
|
|
|
2743
|
|
|
2744 /* decl.c */
|
|
|
2745 bool gfc_in_match_data (void);
|
|
|
2746 match gfc_match_char_spec (gfc_typespec *);
|
|
131
|
2747 extern int directive_unroll;
|
|
111
|
2748
|
|
|
2749 /* Handling Parameterized Derived Types */
|
|
|
2750 bool gfc_insert_kind_parameter_exprs (gfc_expr *);
|
|
|
2751 bool gfc_insert_parameter_exprs (gfc_expr *, gfc_actual_arglist *);
|
|
|
2752 match gfc_get_pdt_instance (gfc_actual_arglist *, gfc_symbol **,
|
|
|
2753 gfc_actual_arglist **);
|
|
|
2754
|
|
|
2755 /* scanner.c */
|
|
|
2756 void gfc_scanner_done_1 (void);
|
|
|
2757 void gfc_scanner_init_1 (void);
|
|
|
2758
|
|
|
2759 void gfc_add_include_path (const char *, bool, bool, bool);
|
|
|
2760 void gfc_add_intrinsic_modules_path (const char *);
|
|
|
2761 void gfc_release_include_path (void);
|
|
|
2762 FILE *gfc_open_included_file (const char *, bool, bool);
|
|
|
2763
|
|
|
2764 int gfc_at_end (void);
|
|
|
2765 int gfc_at_eof (void);
|
|
|
2766 int gfc_at_bol (void);
|
|
|
2767 int gfc_at_eol (void);
|
|
|
2768 void gfc_advance_line (void);
|
|
|
2769 int gfc_check_include (void);
|
|
|
2770 int gfc_define_undef_line (void);
|
|
|
2771
|
|
|
2772 int gfc_wide_is_printable (gfc_char_t);
|
|
|
2773 int gfc_wide_is_digit (gfc_char_t);
|
|
|
2774 int gfc_wide_fits_in_byte (gfc_char_t);
|
|
|
2775 gfc_char_t gfc_wide_tolower (gfc_char_t);
|
|
|
2776 gfc_char_t gfc_wide_toupper (gfc_char_t);
|
|
|
2777 size_t gfc_wide_strlen (const gfc_char_t *);
|
|
|
2778 int gfc_wide_strncasecmp (const gfc_char_t *, const char *, size_t);
|
|
|
2779 gfc_char_t *gfc_wide_memset (gfc_char_t *, gfc_char_t, size_t);
|
|
|
2780 char *gfc_widechar_to_char (const gfc_char_t *, int);
|
|
|
2781 gfc_char_t *gfc_char_to_widechar (const char *);
|
|
|
2782
|
|
|
2783 #define gfc_get_wide_string(n) XCNEWVEC (gfc_char_t, n)
|
|
|
2784
|
|
|
2785 void gfc_skip_comments (void);
|
|
|
2786 gfc_char_t gfc_next_char_literal (gfc_instring);
|
|
|
2787 gfc_char_t gfc_next_char (void);
|
|
|
2788 char gfc_next_ascii_char (void);
|
|
|
2789 gfc_char_t gfc_peek_char (void);
|
|
|
2790 char gfc_peek_ascii_char (void);
|
|
|
2791 void gfc_error_recovery (void);
|
|
|
2792 void gfc_gobble_whitespace (void);
|
|
|
2793 bool gfc_new_file (void);
|
|
|
2794 const char * gfc_read_orig_filename (const char *, const char **);
|
|
|
2795
|
|
|
2796 extern gfc_source_form gfc_current_form;
|
|
|
2797 extern const char *gfc_source_file;
|
|
|
2798 extern locus gfc_current_locus;
|
|
|
2799
|
|
|
2800 void gfc_start_source_files (void);
|
|
|
2801 void gfc_end_source_files (void);
|
|
|
2802
|
|
|
2803 /* misc.c */
|
|
|
2804 void gfc_clear_ts (gfc_typespec *);
|
|
|
2805 FILE *gfc_open_file (const char *);
|
|
|
2806 const char *gfc_basic_typename (bt);
|
|
|
2807 const char *gfc_typename (gfc_typespec *);
|
|
|
2808 const char *gfc_op2string (gfc_intrinsic_op);
|
|
|
2809 const char *gfc_code2string (const mstring *, int);
|
|
|
2810 int gfc_string2code (const mstring *, const char *);
|
|
|
2811 const char *gfc_intent_string (sym_intent);
|
|
|
2812
|
|
|
2813 void gfc_init_1 (void);
|
|
|
2814 void gfc_init_2 (void);
|
|
|
2815 void gfc_done_1 (void);
|
|
|
2816 void gfc_done_2 (void);
|
|
|
2817
|
|
|
2818 int get_c_kind (const char *, CInteropKind_t *);
|
|
|
2819
|
|
|
2820 const char *gfc_closest_fuzzy_match (const char *, char **);
|
|
|
2821 static inline void
|
|
|
2822 vec_push (char **&optr, size_t &osz, const char *elt)
|
|
|
2823 {
|
|
|
2824 /* {auto,}vec.safe_push () replacement. Don't ask.. */
|
|
|
2825 // if (strlen (elt) < 4) return; premature optimization: eliminated by cutoff
|
|
|
2826 optr = XRESIZEVEC (char *, optr, osz + 2);
|
|
|
2827 optr[osz] = CONST_CAST (char *, elt);
|
|
|
2828 optr[++osz] = NULL;
|
|
|
2829 }
|
|
|
2830
|
|
131
|
2831 HOST_WIDE_INT gfc_mpz_get_hwi (mpz_t);
|
|
|
2832 void gfc_mpz_set_hwi (mpz_t, const HOST_WIDE_INT);
|
|
|
2833
|
|
111
|
2834 /* options.c */
|
|
|
2835 unsigned int gfc_option_lang_mask (void);
|
|
|
2836 void gfc_init_options_struct (struct gcc_options *);
|
|
|
2837 void gfc_init_options (unsigned int,
|
|
|
2838 struct cl_decoded_option *);
|
|
131
|
2839 bool gfc_handle_option (size_t, const char *, HOST_WIDE_INT, int, location_t,
|
|
111
|
2840 const struct cl_option_handlers *);
|
|
|
2841 bool gfc_post_options (const char **);
|
|
|
2842 char *gfc_get_option_string (void);
|
|
|
2843
|
|
|
2844 /* f95-lang.c */
|
|
|
2845 void gfc_maybe_initialize_eh (void);
|
|
|
2846
|
|
|
2847 /* iresolve.c */
|
|
|
2848 const char * gfc_get_string (const char *, ...) ATTRIBUTE_PRINTF_1;
|
|
|
2849 bool gfc_find_sym_in_expr (gfc_symbol *, gfc_expr *);
|
|
|
2850
|
|
|
2851 /* error.c */
|
|
|
2852 void gfc_error_init_1 (void);
|
|
|
2853 void gfc_diagnostics_init (void);
|
|
|
2854 void gfc_diagnostics_finish (void);
|
|
|
2855 void gfc_buffer_error (bool);
|
|
|
2856
|
|
|
2857 const char *gfc_print_wide_char (gfc_char_t);
|
|
|
2858
|
|
|
2859 bool gfc_warning (int opt, const char *, ...) ATTRIBUTE_GCC_GFC(2,3);
|
|
|
2860 bool gfc_warning_now (int opt, const char *, ...) ATTRIBUTE_GCC_GFC(2,3);
|
|
|
2861 bool gfc_warning_internal (int opt, const char *, ...) ATTRIBUTE_GCC_GFC(2,3);
|
|
|
2862 bool gfc_warning_now_at (location_t loc, int opt, const char *gmsgid, ...)
|
|
|
2863 ATTRIBUTE_GCC_GFC(3,4);
|
|
|
2864
|
|
|
2865 void gfc_clear_warning (void);
|
|
|
2866 void gfc_warning_check (void);
|
|
|
2867
|
|
|
2868 void gfc_error_opt (int opt, const char *, ...) ATTRIBUTE_GCC_GFC(2,3);
|
|
|
2869 void gfc_error (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
|
|
|
2870 void gfc_error_now (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
|
|
|
2871 void gfc_fatal_error (const char *, ...) ATTRIBUTE_NORETURN ATTRIBUTE_GCC_GFC(1,2);
|
|
|
2872 void gfc_internal_error (const char *, ...) ATTRIBUTE_NORETURN ATTRIBUTE_GCC_GFC(1,2);
|
|
|
2873 void gfc_clear_error (void);
|
|
|
2874 bool gfc_error_check (void);
|
|
|
2875 bool gfc_error_flag_test (void);
|
|
|
2876
|
|
|
2877 notification gfc_notification_std (int);
|
|
|
2878 bool gfc_notify_std (int, const char *, ...) ATTRIBUTE_GCC_GFC(2,3);
|
|
|
2879
|
|
|
2880 /* A general purpose syntax error. */
|
|
|
2881 #define gfc_syntax_error(ST) \
|
|
|
2882 gfc_error ("Syntax error in %s statement at %C", gfc_ascii_statement (ST));
|
|
|
2883
|
|
|
2884 #include "pretty-print.h" /* For output_buffer. */
|
|
|
2885 struct gfc_error_buffer
|
|
|
2886 {
|
|
|
2887 bool flag;
|
|
|
2888 output_buffer buffer;
|
|
|
2889 gfc_error_buffer(void) : flag(false), buffer() {}
|
|
|
2890 };
|
|
|
2891
|
|
|
2892 void gfc_push_error (gfc_error_buffer *);
|
|
|
2893 void gfc_pop_error (gfc_error_buffer *);
|
|
|
2894 void gfc_free_error (gfc_error_buffer *);
|
|
|
2895
|
|
|
2896 void gfc_get_errors (int *, int *);
|
|
|
2897 void gfc_errors_to_warnings (bool);
|
|
|
2898
|
|
|
2899 /* arith.c */
|
|
|
2900 void gfc_arith_init_1 (void);
|
|
|
2901 void gfc_arith_done_1 (void);
|
|
|
2902 arith gfc_check_integer_range (mpz_t p, int kind);
|
|
|
2903 bool gfc_check_character_range (gfc_char_t, int);
|
|
|
2904
|
|
|
2905 /* trans-types.c */
|
|
|
2906 bool gfc_check_any_c_kind (gfc_typespec *);
|
|
|
2907 int gfc_validate_kind (bt, int, bool);
|
|
|
2908 int gfc_get_int_kind_from_width_isofortranenv (int size);
|
|
|
2909 int gfc_get_real_kind_from_width_isofortranenv (int size);
|
|
|
2910 tree gfc_get_union_type (gfc_symbol *);
|
|
|
2911 tree gfc_get_derived_type (gfc_symbol * derived, int codimen = 0);
|
|
|
2912 extern int gfc_index_integer_kind;
|
|
|
2913 extern int gfc_default_integer_kind;
|
|
|
2914 extern int gfc_max_integer_kind;
|
|
|
2915 extern int gfc_default_real_kind;
|
|
|
2916 extern int gfc_default_double_kind;
|
|
|
2917 extern int gfc_default_character_kind;
|
|
|
2918 extern int gfc_default_logical_kind;
|
|
|
2919 extern int gfc_default_complex_kind;
|
|
|
2920 extern int gfc_c_int_kind;
|
|
|
2921 extern int gfc_atomic_int_kind;
|
|
|
2922 extern int gfc_atomic_logical_kind;
|
|
|
2923 extern int gfc_intio_kind;
|
|
|
2924 extern int gfc_charlen_int_kind;
|
|
131
|
2925 extern int gfc_size_kind;
|
|
111
|
2926 extern int gfc_numeric_storage_size;
|
|
|
2927 extern int gfc_character_storage_size;
|
|
|
2928
|
|
131
|
2929 #define gfc_logical_4_kind 4
|
|
|
2930 #define gfc_integer_4_kind 4
|
|
|
2931
|
|
111
|
2932 /* symbol.c */
|
|
|
2933 void gfc_clear_new_implicit (void);
|
|
|
2934 bool gfc_add_new_implicit_range (int, int);
|
|
|
2935 bool gfc_merge_new_implicit (gfc_typespec *);
|
|
|
2936 void gfc_set_implicit_none (bool, bool, locus *);
|
|
|
2937 void gfc_check_function_type (gfc_namespace *);
|
|
|
2938 bool gfc_is_intrinsic_typename (const char *);
|
|
|
2939
|
|
|
2940 gfc_typespec *gfc_get_default_type (const char *, gfc_namespace *);
|
|
|
2941 bool gfc_set_default_type (gfc_symbol *, int, gfc_namespace *);
|
|
|
2942
|
|
|
2943 void gfc_set_sym_referenced (gfc_symbol *);
|
|
|
2944
|
|
|
2945 bool gfc_add_attribute (symbol_attribute *, locus *);
|
|
|
2946 bool gfc_add_ext_attribute (symbol_attribute *, ext_attr_id_t, locus *);
|
|
|
2947 bool gfc_add_allocatable (symbol_attribute *, locus *);
|
|
|
2948 bool gfc_add_codimension (symbol_attribute *, const char *, locus *);
|
|
|
2949 bool gfc_add_contiguous (symbol_attribute *, const char *, locus *);
|
|
|
2950 bool gfc_add_dimension (symbol_attribute *, const char *, locus *);
|
|
|
2951 bool gfc_add_external (symbol_attribute *, locus *);
|
|
|
2952 bool gfc_add_intrinsic (symbol_attribute *, locus *);
|
|
|
2953 bool gfc_add_optional (symbol_attribute *, locus *);
|
|
|
2954 bool gfc_add_kind (symbol_attribute *, locus *);
|
|
|
2955 bool gfc_add_len (symbol_attribute *, locus *);
|
|
|
2956 bool gfc_add_pointer (symbol_attribute *, locus *);
|
|
|
2957 bool gfc_add_cray_pointer (symbol_attribute *, locus *);
|
|
|
2958 bool gfc_add_cray_pointee (symbol_attribute *, locus *);
|
|
|
2959 match gfc_mod_pointee_as (gfc_array_spec *);
|
|
|
2960 bool gfc_add_protected (symbol_attribute *, const char *, locus *);
|
|
|
2961 bool gfc_add_result (symbol_attribute *, const char *, locus *);
|
|
|
2962 bool gfc_add_automatic (symbol_attribute *, const char *, locus *);
|
|
|
2963 bool gfc_add_save (symbol_attribute *, save_state, const char *, locus *);
|
|
|
2964 bool gfc_add_threadprivate (symbol_attribute *, const char *, locus *);
|
|
|
2965 bool gfc_add_omp_declare_target (symbol_attribute *, const char *, locus *);
|
|
|
2966 bool gfc_add_omp_declare_target_link (symbol_attribute *, const char *,
|
|
|
2967 locus *);
|
|
|
2968 bool gfc_add_saved_common (symbol_attribute *, locus *);
|
|
|
2969 bool gfc_add_target (symbol_attribute *, locus *);
|
|
|
2970 bool gfc_add_dummy (symbol_attribute *, const char *, locus *);
|
|
|
2971 bool gfc_add_generic (symbol_attribute *, const char *, locus *);
|
|
|
2972 bool gfc_add_common (symbol_attribute *, locus *);
|
|
|
2973 bool gfc_add_in_common (symbol_attribute *, const char *, locus *);
|
|
|
2974 bool gfc_add_in_equivalence (symbol_attribute *, const char *, locus *);
|
|
|
2975 bool gfc_add_data (symbol_attribute *, const char *, locus *);
|
|
|
2976 bool gfc_add_in_namelist (symbol_attribute *, const char *, locus *);
|
|
|
2977 bool gfc_add_sequence (symbol_attribute *, const char *, locus *);
|
|
|
2978 bool gfc_add_elemental (symbol_attribute *, locus *);
|
|
|
2979 bool gfc_add_pure (symbol_attribute *, locus *);
|
|
|
2980 bool gfc_add_recursive (symbol_attribute *, locus *);
|
|
|
2981 bool gfc_add_function (symbol_attribute *, const char *, locus *);
|
|
|
2982 bool gfc_add_subroutine (symbol_attribute *, const char *, locus *);
|
|
|
2983 bool gfc_add_volatile (symbol_attribute *, const char *, locus *);
|
|
|
2984 bool gfc_add_asynchronous (symbol_attribute *, const char *, locus *);
|
|
|
2985 bool gfc_add_proc (symbol_attribute *attr, const char *name, locus *where);
|
|
|
2986 bool gfc_add_abstract (symbol_attribute* attr, locus* where);
|
|
|
2987
|
|
|
2988 bool gfc_add_access (symbol_attribute *, gfc_access, const char *, locus *);
|
|
|
2989 bool gfc_add_is_bind_c (symbol_attribute *, const char *, locus *, int);
|
|
|
2990 bool gfc_add_extension (symbol_attribute *, locus *);
|
|
|
2991 bool gfc_add_value (symbol_attribute *, const char *, locus *);
|
|
|
2992 bool gfc_add_flavor (symbol_attribute *, sym_flavor, const char *, locus *);
|
|
|
2993 bool gfc_add_entry (symbol_attribute *, const char *, locus *);
|
|
|
2994 bool gfc_add_procedure (symbol_attribute *, procedure_type,
|
|
|
2995 const char *, locus *);
|
|
|
2996 bool gfc_add_intent (symbol_attribute *, sym_intent, locus *);
|
|
|
2997 bool gfc_add_explicit_interface (gfc_symbol *, ifsrc,
|
|
|
2998 gfc_formal_arglist *, locus *);
|
|
|
2999 bool gfc_add_type (gfc_symbol *, gfc_typespec *, locus *);
|
|
|
3000
|
|
|
3001 void gfc_clear_attr (symbol_attribute *);
|
|
|
3002 bool gfc_missing_attr (symbol_attribute *, locus *);
|
|
|
3003 bool gfc_copy_attr (symbol_attribute *, symbol_attribute *, locus *);
|
|
|
3004 int gfc_copy_dummy_sym (gfc_symbol **, gfc_symbol *, int);
|
|
|
3005 bool gfc_add_component (gfc_symbol *, const char *, gfc_component **);
|
|
|
3006 gfc_symbol *gfc_use_derived (gfc_symbol *);
|
|
|
3007 gfc_symtree *gfc_use_derived_tree (gfc_symtree *);
|
|
|
3008 gfc_component *gfc_find_component (gfc_symbol *, const char *, bool, bool,
|
|
|
3009 gfc_ref **);
|
|
|
3010
|
|
|
3011 gfc_st_label *gfc_get_st_label (int);
|
|
|
3012 void gfc_free_st_label (gfc_st_label *);
|
|
|
3013 void gfc_define_st_label (gfc_st_label *, gfc_sl_type, locus *);
|
|
|
3014 bool gfc_reference_st_label (gfc_st_label *, gfc_sl_type);
|
|
|
3015
|
|
|
3016 gfc_namespace *gfc_get_namespace (gfc_namespace *, int);
|
|
|
3017 gfc_symtree *gfc_new_symtree (gfc_symtree **, const char *);
|
|
|
3018 gfc_symtree *gfc_find_symtree (gfc_symtree *, const char *);
|
|
|
3019 void gfc_delete_symtree (gfc_symtree **, const char *);
|
|
|
3020 gfc_symtree *gfc_get_unique_symtree (gfc_namespace *);
|
|
|
3021 gfc_user_op *gfc_get_uop (const char *);
|
|
|
3022 gfc_user_op *gfc_find_uop (const char *, gfc_namespace *);
|
|
|
3023 void gfc_free_symbol (gfc_symbol *);
|
|
|
3024 void gfc_release_symbol (gfc_symbol *);
|
|
|
3025 gfc_symbol *gfc_new_symbol (const char *, gfc_namespace *);
|
|
|
3026 gfc_symtree* gfc_find_symtree_in_proc (const char *, gfc_namespace *);
|
|
|
3027 int gfc_find_symbol (const char *, gfc_namespace *, int, gfc_symbol **);
|
|
|
3028 int gfc_find_sym_tree (const char *, gfc_namespace *, int, gfc_symtree **);
|
|
|
3029 int gfc_get_symbol (const char *, gfc_namespace *, gfc_symbol **);
|
|
|
3030 bool gfc_verify_c_interop (gfc_typespec *);
|
|
|
3031 bool gfc_verify_c_interop_param (gfc_symbol *);
|
|
|
3032 bool verify_bind_c_sym (gfc_symbol *, gfc_typespec *, int, gfc_common_head *);
|
|
|
3033 bool verify_bind_c_derived_type (gfc_symbol *);
|
|
|
3034 bool verify_com_block_vars_c_interop (gfc_common_head *);
|
|
|
3035 gfc_symtree *generate_isocbinding_symbol (const char *, iso_c_binding_symbol,
|
|
|
3036 const char *, gfc_symtree *, bool);
|
|
|
3037 void gfc_save_symbol_data (gfc_symbol *);
|
|
|
3038 int gfc_get_sym_tree (const char *, gfc_namespace *, gfc_symtree **, bool);
|
|
|
3039 int gfc_get_ha_symbol (const char *, gfc_symbol **);
|
|
|
3040 int gfc_get_ha_sym_tree (const char *, gfc_symtree **);
|
|
|
3041
|
|
|
3042 void gfc_drop_last_undo_checkpoint (void);
|
|
|
3043 void gfc_restore_last_undo_checkpoint (void);
|
|
|
3044 void gfc_undo_symbols (void);
|
|
|
3045 void gfc_commit_symbols (void);
|
|
|
3046 void gfc_commit_symbol (gfc_symbol *);
|
|
|
3047 gfc_charlen *gfc_new_charlen (gfc_namespace *, gfc_charlen *);
|
|
|
3048 void gfc_free_charlen (gfc_charlen *, gfc_charlen *);
|
|
|
3049 void gfc_free_namespace (gfc_namespace *);
|
|
|
3050
|
|
|
3051 void gfc_symbol_init_2 (void);
|
|
|
3052 void gfc_symbol_done_2 (void);
|
|
|
3053
|
|
|
3054 void gfc_traverse_symtree (gfc_symtree *, void (*)(gfc_symtree *));
|
|
|
3055 void gfc_traverse_ns (gfc_namespace *, void (*)(gfc_symbol *));
|
|
|
3056 void gfc_traverse_user_op (gfc_namespace *, void (*)(gfc_user_op *));
|
|
|
3057 void gfc_save_all (gfc_namespace *);
|
|
|
3058
|
|
|
3059 void gfc_enforce_clean_symbol_state (void);
|
|
|
3060 void gfc_free_dt_list (void);
|
|
|
3061
|
|
|
3062
|
|
|
3063 gfc_gsymbol *gfc_get_gsymbol (const char *);
|
|
|
3064 gfc_gsymbol *gfc_find_gsymbol (gfc_gsymbol *, const char *);
|
|
131
|
3065 gfc_gsymbol *gfc_find_case_gsymbol (gfc_gsymbol *, const char *);
|
|
111
|
3066
|
|
|
3067 gfc_typebound_proc* gfc_get_typebound_proc (gfc_typebound_proc*);
|
|
|
3068 gfc_symbol* gfc_get_derived_super_type (gfc_symbol*);
|
|
|
3069 gfc_symbol* gfc_get_ultimate_derived_super_type (gfc_symbol*);
|
|
|
3070 bool gfc_type_is_extension_of (gfc_symbol *, gfc_symbol *);
|
|
|
3071 bool gfc_type_compatible (gfc_typespec *, gfc_typespec *);
|
|
|
3072
|
|
|
3073 void gfc_copy_formal_args_intr (gfc_symbol *, gfc_intrinsic_sym *,
|
|
|
3074 gfc_actual_arglist *);
|
|
|
3075
|
|
|
3076 void gfc_free_finalizer (gfc_finalizer *el); /* Needed in resolve.c, too */
|
|
|
3077
|
|
|
3078 bool gfc_check_symbol_typed (gfc_symbol*, gfc_namespace*, bool, locus);
|
|
|
3079 gfc_namespace* gfc_find_proc_namespace (gfc_namespace*);
|
|
|
3080
|
|
|
3081 bool gfc_is_associate_pointer (gfc_symbol*);
|
|
|
3082 gfc_symbol * gfc_find_dt_in_generic (gfc_symbol *);
|
|
|
3083 gfc_formal_arglist *gfc_sym_get_dummy_args (gfc_symbol *);
|
|
|
3084
|
|
|
3085 /* intrinsic.c -- true if working in an init-expr, false otherwise. */
|
|
|
3086 extern bool gfc_init_expr_flag;
|
|
|
3087
|
|
|
3088 /* Given a symbol that we have decided is intrinsic, mark it as such
|
|
|
3089 by placing it into a special module that is otherwise impossible to
|
|
|
3090 read or write. */
|
|
|
3091
|
|
|
3092 #define gfc_intrinsic_symbol(SYM) SYM->module = gfc_get_string ("(intrinsic)")
|
|
|
3093
|
|
|
3094 void gfc_intrinsic_init_1 (void);
|
|
|
3095 void gfc_intrinsic_done_1 (void);
|
|
|
3096
|
|
|
3097 char gfc_type_letter (bt);
|
|
|
3098 gfc_symbol * gfc_get_intrinsic_sub_symbol (const char *);
|
|
|
3099 bool gfc_convert_type (gfc_expr *, gfc_typespec *, int);
|
|
|
3100 bool gfc_convert_type_warn (gfc_expr *, gfc_typespec *, int, int);
|
|
|
3101 bool gfc_convert_chartype (gfc_expr *, gfc_typespec *);
|
|
|
3102 int gfc_generic_intrinsic (const char *);
|
|
|
3103 int gfc_specific_intrinsic (const char *);
|
|
|
3104 bool gfc_is_intrinsic (gfc_symbol*, int, locus);
|
|
|
3105 int gfc_intrinsic_actual_ok (const char *, const bool);
|
|
|
3106 gfc_intrinsic_sym *gfc_find_function (const char *);
|
|
|
3107 gfc_intrinsic_sym *gfc_find_subroutine (const char *);
|
|
|
3108 gfc_intrinsic_sym *gfc_intrinsic_function_by_id (gfc_isym_id);
|
|
|
3109 gfc_intrinsic_sym *gfc_intrinsic_subroutine_by_id (gfc_isym_id);
|
|
|
3110 gfc_isym_id gfc_isym_id_by_intmod (intmod_id, int);
|
|
|
3111 gfc_isym_id gfc_isym_id_by_intmod_sym (gfc_symbol *);
|
|
|
3112
|
|
|
3113
|
|
|
3114 match gfc_intrinsic_func_interface (gfc_expr *, int);
|
|
|
3115 match gfc_intrinsic_sub_interface (gfc_code *, int);
|
|
|
3116
|
|
|
3117 void gfc_warn_intrinsic_shadow (const gfc_symbol*, bool, bool);
|
|
|
3118 bool gfc_check_intrinsic_standard (const gfc_intrinsic_sym*, const char**,
|
|
|
3119 bool, locus);
|
|
|
3120
|
|
|
3121 /* match.c -- FIXME */
|
|
|
3122 void gfc_free_iterator (gfc_iterator *, int);
|
|
|
3123 void gfc_free_forall_iterator (gfc_forall_iterator *);
|
|
|
3124 void gfc_free_alloc_list (gfc_alloc *);
|
|
|
3125 void gfc_free_namelist (gfc_namelist *);
|
|
|
3126 void gfc_free_omp_namelist (gfc_omp_namelist *);
|
|
|
3127 void gfc_free_equiv (gfc_equiv *);
|
|
|
3128 void gfc_free_equiv_until (gfc_equiv *, gfc_equiv *);
|
|
|
3129 void gfc_free_data (gfc_data *);
|
|
|
3130 void gfc_reject_data (gfc_namespace *);
|
|
|
3131 void gfc_free_case_list (gfc_case *);
|
|
|
3132
|
|
|
3133 /* matchexp.c -- FIXME too? */
|
|
|
3134 gfc_expr *gfc_get_parentheses (gfc_expr *);
|
|
|
3135
|
|
|
3136 /* openmp.c */
|
|
|
3137 struct gfc_omp_saved_state { void *ptrs[2]; int ints[1]; };
|
|
|
3138 void gfc_free_omp_clauses (gfc_omp_clauses *);
|
|
|
3139 void gfc_free_oacc_declare_clauses (struct gfc_oacc_declare *);
|
|
|
3140 void gfc_free_omp_declare_simd (gfc_omp_declare_simd *);
|
|
|
3141 void gfc_free_omp_declare_simd_list (gfc_omp_declare_simd *);
|
|
|
3142 void gfc_free_omp_udr (gfc_omp_udr *);
|
|
|
3143 gfc_omp_udr *gfc_omp_udr_find (gfc_symtree *, gfc_typespec *);
|
|
|
3144 void gfc_resolve_omp_directive (gfc_code *, gfc_namespace *);
|
|
|
3145 void gfc_resolve_do_iterator (gfc_code *, gfc_symbol *, bool);
|
|
|
3146 void gfc_resolve_omp_local_vars (gfc_namespace *);
|
|
|
3147 void gfc_resolve_omp_parallel_blocks (gfc_code *, gfc_namespace *);
|
|
|
3148 void gfc_resolve_omp_do_blocks (gfc_code *, gfc_namespace *);
|
|
|
3149 void gfc_resolve_omp_declare_simd (gfc_namespace *);
|
|
|
3150 void gfc_resolve_omp_udrs (gfc_symtree *);
|
|
|
3151 void gfc_omp_save_and_clear_state (struct gfc_omp_saved_state *);
|
|
|
3152 void gfc_omp_restore_state (struct gfc_omp_saved_state *);
|
|
|
3153 void gfc_free_expr_list (gfc_expr_list *);
|
|
|
3154 void gfc_resolve_oacc_directive (gfc_code *, gfc_namespace *);
|
|
|
3155 void gfc_resolve_oacc_declare (gfc_namespace *);
|
|
|
3156 void gfc_resolve_oacc_parallel_loop_blocks (gfc_code *, gfc_namespace *);
|
|
|
3157 void gfc_resolve_oacc_blocks (gfc_code *, gfc_namespace *);
|
|
|
3158
|
|
|
3159 /* expr.c */
|
|
|
3160 void gfc_free_actual_arglist (gfc_actual_arglist *);
|
|
|
3161 gfc_actual_arglist *gfc_copy_actual_arglist (gfc_actual_arglist *);
|
|
131
|
3162
|
|
111
|
3163 bool gfc_extract_int (gfc_expr *, int *, int = 0);
|
|
131
|
3164 bool gfc_extract_hwi (gfc_expr *, HOST_WIDE_INT *, int = 0);
|
|
|
3165
|
|
111
|
3166 bool is_subref_array (gfc_expr *);
|
|
|
3167 bool gfc_is_simply_contiguous (gfc_expr *, bool, bool);
|
|
|
3168 bool gfc_check_init_expr (gfc_expr *);
|
|
|
3169
|
|
|
3170 gfc_expr *gfc_build_conversion (gfc_expr *);
|
|
|
3171 void gfc_free_ref_list (gfc_ref *);
|
|
|
3172 void gfc_type_convert_binary (gfc_expr *, int);
|
|
|
3173 bool gfc_is_constant_expr (gfc_expr *);
|
|
|
3174 bool gfc_simplify_expr (gfc_expr *, int);
|
|
|
3175 int gfc_has_vector_index (gfc_expr *);
|
|
|
3176
|
|
|
3177 gfc_expr *gfc_get_expr (void);
|
|
|
3178 gfc_expr *gfc_get_array_expr (bt type, int kind, locus *);
|
|
|
3179 gfc_expr *gfc_get_null_expr (locus *);
|
|
|
3180 gfc_expr *gfc_get_operator_expr (locus *, gfc_intrinsic_op,gfc_expr *, gfc_expr *);
|
|
|
3181 gfc_expr *gfc_get_structure_constructor_expr (bt, int, locus *);
|
|
|
3182 gfc_expr *gfc_get_constant_expr (bt, int, locus *);
|
|
131
|
3183 gfc_expr *gfc_get_character_expr (int, locus *, const char *, gfc_charlen_t len);
|
|
|
3184 gfc_expr *gfc_get_int_expr (int, locus *, HOST_WIDE_INT);
|
|
111
|
3185 gfc_expr *gfc_get_logical_expr (int, locus *, bool);
|
|
|
3186 gfc_expr *gfc_get_iokind_expr (locus *, io_kind);
|
|
|
3187
|
|
|
3188 void gfc_clear_shape (mpz_t *shape, int rank);
|
|
|
3189 void gfc_free_shape (mpz_t **shape, int rank);
|
|
|
3190 void gfc_free_expr (gfc_expr *);
|
|
|
3191 void gfc_replace_expr (gfc_expr *, gfc_expr *);
|
|
|
3192 mpz_t *gfc_copy_shape (mpz_t *, int);
|
|
|
3193 mpz_t *gfc_copy_shape_excluding (mpz_t *, int, gfc_expr *);
|
|
|
3194 gfc_expr *gfc_copy_expr (gfc_expr *);
|
|
|
3195 gfc_ref* gfc_copy_ref (gfc_ref*);
|
|
|
3196
|
|
|
3197 bool gfc_specification_expr (gfc_expr *);
|
|
|
3198
|
|
|
3199 int gfc_numeric_ts (gfc_typespec *);
|
|
|
3200 int gfc_kind_max (gfc_expr *, gfc_expr *);
|
|
|
3201
|
|
|
3202 bool gfc_check_conformance (gfc_expr *, gfc_expr *, const char *, ...) ATTRIBUTE_PRINTF_3;
|
|
|
3203 bool gfc_check_assign (gfc_expr *, gfc_expr *, int, bool c = true);
|
|
|
3204 bool gfc_check_pointer_assign (gfc_expr *, gfc_expr *);
|
|
|
3205 bool gfc_check_assign_symbol (gfc_symbol *, gfc_component *, gfc_expr *);
|
|
|
3206
|
|
|
3207 gfc_expr *gfc_build_default_init_expr (gfc_typespec *, locus *);
|
|
131
|
3208 gfc_expr *gfc_build_init_expr (gfc_typespec *, locus *, bool);
|
|
111
|
3209 void gfc_apply_init (gfc_typespec *, symbol_attribute *, gfc_expr *);
|
|
|
3210 bool gfc_has_default_initializer (gfc_symbol *);
|
|
|
3211 gfc_expr *gfc_default_initializer (gfc_typespec *);
|
|
|
3212 gfc_expr *gfc_generate_initializer (gfc_typespec *, bool);
|
|
|
3213 gfc_expr *gfc_get_variable_expr (gfc_symtree *);
|
|
|
3214 void gfc_add_full_array_ref (gfc_expr *, gfc_array_spec *);
|
|
|
3215 gfc_expr * gfc_lval_expr_from_sym (gfc_symbol *);
|
|
|
3216
|
|
|
3217 gfc_array_spec *gfc_get_full_arrayspec_from_expr (gfc_expr *expr);
|
|
|
3218
|
|
|
3219 bool gfc_traverse_expr (gfc_expr *, gfc_symbol *,
|
|
|
3220 bool (*)(gfc_expr *, gfc_symbol *, int*),
|
|
|
3221 int);
|
|
|
3222 void gfc_expr_set_symbols_referenced (gfc_expr *);
|
|
|
3223 bool gfc_expr_check_typed (gfc_expr*, gfc_namespace*, bool);
|
|
|
3224 bool gfc_derived_parameter_expr (gfc_expr *);
|
|
|
3225 gfc_param_spec_type gfc_spec_list_type (gfc_actual_arglist *, gfc_symbol *);
|
|
|
3226 gfc_component * gfc_get_proc_ptr_comp (gfc_expr *);
|
|
|
3227 bool gfc_is_proc_ptr_comp (gfc_expr *);
|
|
|
3228 bool gfc_is_alloc_class_scalar_function (gfc_expr *);
|
|
131
|
3229 bool gfc_is_class_array_function (gfc_expr *);
|
|
111
|
3230
|
|
|
3231 bool gfc_ref_this_image (gfc_ref *ref);
|
|
|
3232 bool gfc_is_coindexed (gfc_expr *);
|
|
|
3233 bool gfc_is_coarray (gfc_expr *);
|
|
|
3234 int gfc_get_corank (gfc_expr *);
|
|
|
3235 bool gfc_has_ultimate_allocatable (gfc_expr *);
|
|
|
3236 bool gfc_has_ultimate_pointer (gfc_expr *);
|
|
131
|
3237 gfc_expr* gfc_find_team_co (gfc_expr *);
|
|
111
|
3238 gfc_expr* gfc_find_stat_co (gfc_expr *);
|
|
|
3239 gfc_expr* gfc_build_intrinsic_call (gfc_namespace *, gfc_isym_id, const char*,
|
|
|
3240 locus, unsigned, ...);
|
|
|
3241 bool gfc_check_vardef_context (gfc_expr*, bool, bool, bool, const char*);
|
|
|
3242
|
|
|
3243
|
|
|
3244 /* st.c */
|
|
|
3245 extern gfc_code new_st;
|
|
|
3246
|
|
|
3247 void gfc_clear_new_st (void);
|
|
|
3248 gfc_code *gfc_get_code (gfc_exec_op);
|
|
|
3249 gfc_code *gfc_append_code (gfc_code *, gfc_code *);
|
|
|
3250 void gfc_free_statement (gfc_code *);
|
|
|
3251 void gfc_free_statements (gfc_code *);
|
|
|
3252 void gfc_free_association_list (gfc_association_list *);
|
|
|
3253
|
|
|
3254 /* resolve.c */
|
|
|
3255 bool gfc_resolve_expr (gfc_expr *);
|
|
|
3256 void gfc_resolve (gfc_namespace *);
|
|
|
3257 void gfc_resolve_code (gfc_code *, gfc_namespace *);
|
|
|
3258 void gfc_resolve_blocks (gfc_code *, gfc_namespace *);
|
|
|
3259 int gfc_impure_variable (gfc_symbol *);
|
|
|
3260 int gfc_pure (gfc_symbol *);
|
|
|
3261 int gfc_implicit_pure (gfc_symbol *);
|
|
|
3262 void gfc_unset_implicit_pure (gfc_symbol *);
|
|
|
3263 int gfc_elemental (gfc_symbol *);
|
|
|
3264 bool gfc_resolve_iterator (gfc_iterator *, bool, bool);
|
|
|
3265 bool find_forall_index (gfc_expr *, gfc_symbol *, int);
|
|
|
3266 bool gfc_resolve_index (gfc_expr *, int);
|
|
|
3267 bool gfc_resolve_dim_arg (gfc_expr *);
|
|
|
3268 bool gfc_is_formal_arg (void);
|
|
|
3269 void gfc_resolve_substring_charlen (gfc_expr *);
|
|
|
3270 match gfc_iso_c_sub_interface(gfc_code *, gfc_symbol *);
|
|
|
3271 gfc_expr *gfc_expr_to_initialize (gfc_expr *);
|
|
|
3272 bool gfc_type_is_extensible (gfc_symbol *);
|
|
|
3273 bool gfc_resolve_intrinsic (gfc_symbol *, locus *);
|
|
|
3274 bool gfc_explicit_interface_required (gfc_symbol *, char *, int);
|
|
|
3275 extern int gfc_do_concurrent_flag;
|
|
|
3276 const char* gfc_lookup_function_fuzzy (const char *, gfc_symtree *);
|
|
131
|
3277 int gfc_pure_function (gfc_expr *e, const char **name);
|
|
|
3278 int gfc_implicit_pure_function (gfc_expr *e);
|
|
111
|
3279
|
|
|
3280
|
|
|
3281 /* array.c */
|
|
|
3282 gfc_iterator *gfc_copy_iterator (gfc_iterator *);
|
|
|
3283
|
|
|
3284 void gfc_free_array_spec (gfc_array_spec *);
|
|
|
3285 gfc_array_ref *gfc_copy_array_ref (gfc_array_ref *);
|
|
|
3286
|
|
|
3287 bool gfc_set_array_spec (gfc_symbol *, gfc_array_spec *, locus *);
|
|
|
3288 gfc_array_spec *gfc_copy_array_spec (gfc_array_spec *);
|
|
|
3289 bool gfc_resolve_array_spec (gfc_array_spec *, int);
|
|
|
3290
|
|
|
3291 int gfc_compare_array_spec (gfc_array_spec *, gfc_array_spec *);
|
|
|
3292
|
|
|
3293 void gfc_simplify_iterator_var (gfc_expr *);
|
|
|
3294 bool gfc_expand_constructor (gfc_expr *, bool);
|
|
|
3295 int gfc_constant_ac (gfc_expr *);
|
|
|
3296 int gfc_expanded_ac (gfc_expr *);
|
|
|
3297 bool gfc_resolve_character_array_constructor (gfc_expr *);
|
|
|
3298 bool gfc_resolve_array_constructor (gfc_expr *);
|
|
|
3299 bool gfc_check_constructor_type (gfc_expr *);
|
|
|
3300 bool gfc_check_iter_variable (gfc_expr *);
|
|
|
3301 bool gfc_check_constructor (gfc_expr *, bool (*)(gfc_expr *));
|
|
|
3302 bool gfc_array_size (gfc_expr *, mpz_t *);
|
|
|
3303 bool gfc_array_dimen_size (gfc_expr *, int, mpz_t *);
|
|
|
3304 bool gfc_array_ref_shape (gfc_array_ref *, mpz_t *);
|
|
|
3305 gfc_array_ref *gfc_find_array_ref (gfc_expr *, bool a = false);
|
|
|
3306 tree gfc_conv_array_initializer (tree type, gfc_expr *);
|
|
|
3307 bool spec_size (gfc_array_spec *, mpz_t *);
|
|
|
3308 bool spec_dimen_size (gfc_array_spec *, int, mpz_t *);
|
|
|
3309 bool gfc_is_compile_time_shape (gfc_array_spec *);
|
|
|
3310
|
|
|
3311 bool gfc_ref_dimen_size (gfc_array_ref *, int dimen, mpz_t *, mpz_t *);
|
|
|
3312
|
|
|
3313
|
|
131
|
3314 #define gfc_str_startswith(str, pref) \
|
|
|
3315 (strncmp ((str), (pref), strlen (pref)) == 0)
|
|
|
3316
|
|
111
|
3317 /* interface.c -- FIXME: some of these should be in symbol.c */
|
|
|
3318 void gfc_free_interface (gfc_interface *);
|
|
|
3319 bool gfc_compare_derived_types (gfc_symbol *, gfc_symbol *);
|
|
|
3320 bool gfc_compare_types (gfc_typespec *, gfc_typespec *);
|
|
|
3321 bool gfc_check_dummy_characteristics (gfc_symbol *, gfc_symbol *,
|
|
|
3322 bool, char *, int);
|
|
|
3323 bool gfc_check_result_characteristics (gfc_symbol *, gfc_symbol *,
|
|
|
3324 char *, int);
|
|
|
3325 bool gfc_compare_interfaces (gfc_symbol*, gfc_symbol*, const char *, int, int,
|
|
|
3326 char *, int, const char *, const char *);
|
|
|
3327 void gfc_check_interfaces (gfc_namespace *);
|
|
|
3328 bool gfc_procedure_use (gfc_symbol *, gfc_actual_arglist **, locus *);
|
|
|
3329 void gfc_ppc_use (gfc_component *, gfc_actual_arglist **, locus *);
|
|
|
3330 gfc_symbol *gfc_search_interface (gfc_interface *, int,
|
|
|
3331 gfc_actual_arglist **);
|
|
|
3332 match gfc_extend_expr (gfc_expr *);
|
|
|
3333 void gfc_free_formal_arglist (gfc_formal_arglist *);
|
|
|
3334 bool gfc_extend_assign (gfc_code *, gfc_namespace *);
|
|
|
3335 bool gfc_check_new_interface (gfc_interface *, gfc_symbol *, locus);
|
|
|
3336 bool gfc_add_interface (gfc_symbol *);
|
|
|
3337 gfc_interface *gfc_current_interface_head (void);
|
|
|
3338 void gfc_set_current_interface_head (gfc_interface *);
|
|
|
3339 gfc_symtree* gfc_find_sym_in_symtree (gfc_symbol*);
|
|
|
3340 bool gfc_arglist_matches_symbol (gfc_actual_arglist**, gfc_symbol*);
|
|
|
3341 bool gfc_check_operator_interface (gfc_symbol*, gfc_intrinsic_op, locus);
|
|
|
3342 bool gfc_has_vector_subscript (gfc_expr*);
|
|
|
3343 gfc_intrinsic_op gfc_equivalent_op (gfc_intrinsic_op);
|
|
|
3344 bool gfc_check_typebound_override (gfc_symtree*, gfc_symtree*);
|
|
|
3345 void gfc_check_dtio_interfaces (gfc_symbol*);
|
|
|
3346 gfc_symtree* gfc_find_typebound_dtio_proc (gfc_symbol *, bool, bool);
|
|
|
3347 gfc_symbol* gfc_find_specific_dtio_proc (gfc_symbol*, bool, bool);
|
|
|
3348
|
|
|
3349
|
|
|
3350 /* io.c */
|
|
|
3351 extern gfc_st_label format_asterisk;
|
|
|
3352
|
|
|
3353 void gfc_free_open (gfc_open *);
|
|
|
3354 bool gfc_resolve_open (gfc_open *);
|
|
|
3355 void gfc_free_close (gfc_close *);
|
|
|
3356 bool gfc_resolve_close (gfc_close *);
|
|
|
3357 void gfc_free_filepos (gfc_filepos *);
|
|
|
3358 bool gfc_resolve_filepos (gfc_filepos *);
|
|
|
3359 void gfc_free_inquire (gfc_inquire *);
|
|
|
3360 bool gfc_resolve_inquire (gfc_inquire *);
|
|
|
3361 void gfc_free_dt (gfc_dt *);
|
|
|
3362 bool gfc_resolve_dt (gfc_dt *, locus *);
|
|
|
3363 void gfc_free_wait (gfc_wait *);
|
|
|
3364 bool gfc_resolve_wait (gfc_wait *);
|
|
|
3365 extern bool async_io_dt;
|
|
|
3366
|
|
|
3367 /* module.c */
|
|
|
3368 void gfc_module_init_2 (void);
|
|
|
3369 void gfc_module_done_2 (void);
|
|
|
3370 void gfc_dump_module (const char *, int);
|
|
|
3371 bool gfc_check_symbol_access (gfc_symbol *);
|
|
|
3372 void gfc_free_use_stmts (gfc_use_list *);
|
|
|
3373 const char *gfc_dt_lower_string (const char *);
|
|
|
3374 const char *gfc_dt_upper_string (const char *);
|
|
|
3375
|
|
|
3376 /* primary.c */
|
|
|
3377 symbol_attribute gfc_variable_attr (gfc_expr *, gfc_typespec *);
|
|
|
3378 symbol_attribute gfc_expr_attr (gfc_expr *);
|
|
|
3379 symbol_attribute gfc_caf_attr (gfc_expr *, bool i = false, bool *r = NULL);
|
|
|
3380 match gfc_match_rvalue (gfc_expr **);
|
|
|
3381 match gfc_match_varspec (gfc_expr*, int, bool, bool);
|
|
|
3382 int gfc_check_digit (char, int);
|
|
|
3383 bool gfc_is_function_return_value (gfc_symbol *, gfc_namespace *);
|
|
|
3384 bool gfc_convert_to_structure_constructor (gfc_expr *, gfc_symbol *,
|
|
|
3385 gfc_expr **,
|
|
|
3386 gfc_actual_arglist **, bool);
|
|
|
3387
|
|
|
3388 /* trans.c */
|
|
|
3389 void gfc_generate_code (gfc_namespace *);
|
|
|
3390 void gfc_generate_module_code (gfc_namespace *);
|
|
|
3391
|
|
|
3392 /* trans-intrinsic.c */
|
|
|
3393 bool gfc_inline_intrinsic_function_p (gfc_expr *);
|
|
|
3394
|
|
|
3395 /* bbt.c */
|
|
|
3396 typedef int (*compare_fn) (void *, void *);
|
|
|
3397 void gfc_insert_bbt (void *, void *, compare_fn);
|
|
|
3398 void gfc_delete_bbt (void *, void *, compare_fn);
|
|
|
3399
|
|
|
3400 /* dump-parse-tree.c */
|
|
|
3401 void gfc_dump_parse_tree (gfc_namespace *, FILE *);
|
|
|
3402 void gfc_dump_c_prototypes (gfc_namespace *, FILE *);
|
|
|
3403
|
|
|
3404 /* parse.c */
|
|
|
3405 bool gfc_parse_file (void);
|
|
|
3406 void gfc_global_used (gfc_gsymbol *, locus *);
|
|
|
3407 gfc_namespace* gfc_build_block_ns (gfc_namespace *);
|
|
|
3408
|
|
|
3409 /* dependency.c */
|
|
|
3410 int gfc_dep_compare_functions (gfc_expr *, gfc_expr *, bool);
|
|
|
3411 int gfc_dep_compare_expr (gfc_expr *, gfc_expr *);
|
|
|
3412 bool gfc_dep_difference (gfc_expr *, gfc_expr *, mpz_t *);
|
|
|
3413
|
|
|
3414 /* check.c */
|
|
|
3415 bool gfc_check_same_strlen (const gfc_expr*, const gfc_expr*, const char*);
|
|
|
3416 bool gfc_calculate_transfer_sizes (gfc_expr*, gfc_expr*, gfc_expr*,
|
|
|
3417 size_t*, size_t*, size_t*);
|
|
|
3418
|
|
|
3419 /* class.c */
|
|
|
3420 void gfc_fix_class_refs (gfc_expr *e);
|
|
|
3421 void gfc_add_component_ref (gfc_expr *, const char *);
|
|
|
3422 void gfc_add_class_array_ref (gfc_expr *);
|
|
|
3423 #define gfc_add_data_component(e) gfc_add_component_ref(e,"_data")
|
|
|
3424 #define gfc_add_vptr_component(e) gfc_add_component_ref(e,"_vptr")
|
|
|
3425 #define gfc_add_len_component(e) gfc_add_component_ref(e,"_len")
|
|
|
3426 #define gfc_add_hash_component(e) gfc_add_component_ref(e,"_hash")
|
|
|
3427 #define gfc_add_size_component(e) gfc_add_component_ref(e,"_size")
|
|
|
3428 #define gfc_add_def_init_component(e) gfc_add_component_ref(e,"_def_init")
|
|
|
3429 #define gfc_add_final_component(e) gfc_add_component_ref(e,"_final")
|
|
|
3430 bool gfc_is_class_array_ref (gfc_expr *, bool *);
|
|
|
3431 bool gfc_is_class_scalar_expr (gfc_expr *);
|
|
|
3432 bool gfc_is_class_container_ref (gfc_expr *e);
|
|
|
3433 gfc_expr *gfc_class_initializer (gfc_typespec *, gfc_expr *);
|
|
|
3434 unsigned int gfc_hash_value (gfc_symbol *);
|
|
|
3435 gfc_expr *gfc_get_len_component (gfc_expr *e);
|
|
|
3436 bool gfc_build_class_symbol (gfc_typespec *, symbol_attribute *,
|
|
|
3437 gfc_array_spec **);
|
|
|
3438 gfc_symbol *gfc_find_derived_vtab (gfc_symbol *);
|
|
|
3439 gfc_symbol *gfc_find_vtab (gfc_typespec *);
|
|
|
3440 gfc_symtree* gfc_find_typebound_proc (gfc_symbol*, bool*,
|
|
|
3441 const char*, bool, locus*);
|
|
|
3442 gfc_symtree* gfc_find_typebound_user_op (gfc_symbol*, bool*,
|
|
|
3443 const char*, bool, locus*);
|
|
|
3444 gfc_typebound_proc* gfc_find_typebound_intrinsic_op (gfc_symbol*, bool*,
|
|
|
3445 gfc_intrinsic_op, bool,
|
|
|
3446 locus*);
|
|
|
3447 gfc_symtree* gfc_get_tbp_symtree (gfc_symtree**, const char*);
|
|
|
3448 bool gfc_is_finalizable (gfc_symbol *, gfc_expr **);
|
|
|
3449
|
|
|
3450 #define CLASS_DATA(sym) sym->ts.u.derived->components
|
|
|
3451 #define UNLIMITED_POLY(sym) \
|
|
|
3452 (sym != NULL && sym->ts.type == BT_CLASS \
|
|
|
3453 && CLASS_DATA (sym) \
|
|
|
3454 && CLASS_DATA (sym)->ts.u.derived \
|
|
|
3455 && CLASS_DATA (sym)->ts.u.derived->attr.unlimited_polymorphic)
|
|
|
3456 #define IS_CLASS_ARRAY(sym) \
|
|
|
3457 (sym->ts.type == BT_CLASS \
|
|
|
3458 && CLASS_DATA (sym) \
|
|
|
3459 && CLASS_DATA (sym)->attr.dimension \
|
|
|
3460 && !CLASS_DATA (sym)->attr.class_pointer)
|
|
|
3461
|
|
|
3462 /* frontend-passes.c */
|
|
|
3463
|
|
|
3464 void gfc_run_passes (gfc_namespace *);
|
|
|
3465
|
|
|
3466 typedef int (*walk_code_fn_t) (gfc_code **, int *, void *);
|
|
|
3467 typedef int (*walk_expr_fn_t) (gfc_expr **, int *, void *);
|
|
|
3468
|
|
|
3469 int gfc_dummy_code_callback (gfc_code **, int *, void *);
|
|
|
3470 int gfc_expr_walker (gfc_expr **, walk_expr_fn_t, void *);
|
|
|
3471 int gfc_code_walker (gfc_code **, walk_code_fn_t, walk_expr_fn_t, void *);
|
|
|
3472
|
|
|
3473 /* simplify.c */
|
|
|
3474
|
|
|
3475 void gfc_convert_mpz_to_signed (mpz_t, int);
|
|
|
3476 gfc_expr *gfc_simplify_ieee_functions (gfc_expr *);
|
|
131
|
3477 bool gfc_is_size_zero_array (gfc_expr *);
|
|
111
|
3478
|
|
|
3479 /* trans-array.c */
|
|
|
3480
|
|
|
3481 bool gfc_is_reallocatable_lhs (gfc_expr *);
|
|
|
3482
|
|
|
3483 /* trans-decl.c */
|
|
|
3484
|
|
|
3485 void finish_oacc_declare (gfc_namespace *, gfc_symbol *, bool);
|
|
|
3486
|
|
|
3487 #endif /* GCC_GFORTRAN_H */
|
