OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [fortran/] [trans.h] - Blame information for rev 328

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 285 jeremybenn
/* Header for code translation functions
2
   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3
   Free Software Foundation, Inc.
4
   Contributed by Paul Brook
5
 
6
This file is part of GCC.
7
 
8
GCC is free software; you can redistribute it and/or modify it under
9
the terms of the GNU General Public License as published by the Free
10
Software Foundation; either version 3, or (at your option) any later
11
version.
12
 
13
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14
WARRANTY; without even the implied warranty of MERCHANTABILITY or
15
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16
for more details.
17
 
18
You should have received a copy of the GNU General Public License
19
along with GCC; see the file COPYING3.  If not see
20
<http://www.gnu.org/licenses/>.  */
21
 
22
#ifndef GFC_TRANS_H
23
#define GFC_TRANS_H
24
 
25
/* Mangled symbols take the form __module__name.  */
26
#define GFC_MAX_MANGLED_SYMBOL_LEN  (GFC_MAX_SYMBOL_LEN*2+4)
27
 
28
/* Struct for holding a block of statements.  It should be treated as an
29
   opaque entity and not modified directly.  This allows us to change the
30
   underlying representation of statement lists.  */
31
typedef struct
32
{
33
  tree head;
34
  unsigned int has_scope:1;
35
}
36
stmtblock_t;
37
 
38
/* a simplified expression */
39
typedef struct gfc_se
40
{
41
  /* Code blocks to be executed before and after using the value.  */
42
  stmtblock_t pre;
43
  stmtblock_t post;
44
 
45
  /* the result of the expression */
46
  tree expr;
47
 
48
  /* The length of a character string value.  */
49
  tree string_length;
50
 
51
  /* If set gfc_conv_variable will return an expression for the array
52
     descriptor. When set, want_pointer should also be set.
53
     If not set scalarizing variables will be substituted.  */
54
  unsigned descriptor_only:1;
55
 
56
  /* When this is set gfc_conv_expr returns the address of a variable.  Only
57
     applies to EXPR_VARIABLE nodes.
58
     Also used by gfc_conv_array_parameter. When set this indicates a pointer
59
     to the descriptor should be returned, rather than the descriptor itself.
60
   */
61
  unsigned want_pointer:1;
62
 
63
  /* An array function call returning without a temporary.  Also used for array
64
     pointer assignments.  */
65
  unsigned direct_byref:1;
66
 
67
  /* Ignore absent optional arguments.  Used for some intrinsics.  */
68
  unsigned ignore_optional:1;
69
 
70
  /* When this is set the data and offset fields of the returned descriptor
71
     are NULL.  Used by intrinsic size.  */
72
  unsigned data_not_needed:1;
73
 
74
  /* If set, gfc_conv_procedure_call does not put byref calls into se->pre.  */
75
  unsigned no_function_call:1;
76
 
77
  /* Scalarization parameters.  */
78
  struct gfc_se *parent;
79
  struct gfc_ss *ss;
80
  struct gfc_loopinfo *loop;
81
}
82
gfc_se;
83
 
84
 
85
/* Scalarization State chain.  Created by walking an expression tree before
86
   creating the scalarization loops. Then passed as part of a gfc_se structure
87
   to translate the expression inside the loop.  Note that these chains are
88
   terminated by gfc_se_terminator, not NULL.  A NULL pointer in a gfc_se
89
   indicates to gfc_conv_* that this is a scalar expression.
90
   Note that some member arrays correspond to scalarizer rank and others
91
   are the variable rank.  */
92
 
93
typedef struct gfc_ss_info
94
{
95
  int dimen;
96
  /* The ref that holds information on this section.  */
97
  gfc_ref *ref;
98
  /* The descriptor of this array.  */
99
  tree descriptor;
100
  /* holds the pointer to the data array.  */
101
  tree data;
102
  /* To move some of the array index calculation out of the innermost loop.  */
103
  tree offset;
104
  tree saved_offset;
105
  tree stride0;
106
  /* Holds the SS for a subscript.  Indexed by actual dimension.  */
107
  struct gfc_ss *subscript[GFC_MAX_DIMENSIONS];
108
 
109
  /* stride and delta are used to access this inside a scalarization loop.
110
     start is used in the calculation of these.  Indexed by scalarizer
111
     dimension.  */
112
  tree start[GFC_MAX_DIMENSIONS];
113
  tree end[GFC_MAX_DIMENSIONS];
114
  tree stride[GFC_MAX_DIMENSIONS];
115
  tree delta[GFC_MAX_DIMENSIONS];
116
 
117
  /* Translation from scalarizer dimensions to actual dimensions.
118
     actual = dim[scalarizer]  */
119
  int dim[GFC_MAX_DIMENSIONS];
120
}
121
gfc_ss_info;
122
 
123
typedef enum
124
{
125
  /* A scalar value.  This will be evaluated before entering the
126
     scalarization loop.  */
127
  GFC_SS_SCALAR,
128
 
129
  /* Like GFC_SS_SCALAR it evaluates the expression outside the
130
     loop. Is always evaluated as a reference to the temporary.
131
     Used for elemental function arguments.  */
132
  GFC_SS_REFERENCE,
133
 
134
  /* An array section.  Scalarization indices will be substituted during
135
     expression translation.  */
136
  GFC_SS_SECTION,
137
 
138
  /* A non-elemental function call returning an array.  The call is executed
139
     before entering the scalarization loop, storing the result in a
140
     temporary.  This temporary is then used inside the scalarization loop.
141
     Simple assignments, e.g. a(:) = fn(), are handled without a temporary
142
     as a special case.  */
143
  GFC_SS_FUNCTION,
144
 
145
  /* An array constructor.  The current implementation is sub-optimal in
146
     many cases.  It allocated a temporary, assigns the values to it, then
147
     uses this temporary inside the scalarization loop.  */
148
  GFC_SS_CONSTRUCTOR,
149
 
150
  /* A vector subscript.  The vector's descriptor is cached in the
151
     "descriptor" field of the associated gfc_ss_info.  */
152
  GFC_SS_VECTOR,
153
 
154
  /* A temporary array allocated by the scalarizer.  Its rank can be less
155
     than that of the assignment expression.  */
156
  GFC_SS_TEMP,
157
 
158
  /* An intrinsic function call.  Many intrinsic functions which map directly
159
     to library calls are created as GFC_SS_FUNCTION nodes.  */
160
  GFC_SS_INTRINSIC,
161
 
162
  /* A component of a derived type.  */
163
  GFC_SS_COMPONENT
164
}
165
gfc_ss_type;
166
 
167
/* SS structures can only belong to a single loopinfo.  They must be added
168
   otherwise they will not get freed.  */
169
typedef struct gfc_ss
170
{
171
  gfc_ss_type type;
172
  gfc_expr *expr;
173
  mpz_t *shape;
174
  tree string_length;
175
  union
176
  {
177
    /* If type is GFC_SS_SCALAR or GFC_SS_REFERENCE.  */
178
    struct
179
    {
180
      tree expr;
181
    }
182
    scalar;
183
 
184
    /* GFC_SS_TEMP.  */
185
    struct
186
    {
187
      /* The rank of the temporary.  May be less than the rank of the
188
         assigned expression.  */
189
      int dimen;
190
      tree type;
191
    }
192
    temp;
193
    /* All other types.  */
194
    gfc_ss_info info;
195
  }
196
  data;
197
 
198
  /* All the SS in a loop and linked through loop_chain.  The SS for an
199
     expression are linked by the next pointer.  */
200
  struct gfc_ss *loop_chain;
201
  struct gfc_ss *next;
202
 
203
  /* This is used by assignments requiring temporaries. The bits specify which
204
     loops the terms appear in.  This will be 1 for the RHS expressions,
205
     2 for the LHS expressions, and 3(=1|2) for the temporary.  The bit
206
     'where' suppresses precalculation of scalars in WHERE assignments.  */
207
  unsigned useflags:2, where:1;
208
}
209
gfc_ss;
210
#define gfc_get_ss() XCNEW (gfc_ss)
211
 
212
/* The contents of this aren't actually used.  A NULL SS chain indicates a
213
   scalar expression, so this pointer is used to terminate SS chains.  */
214
extern gfc_ss * const gfc_ss_terminator;
215
 
216
/* Holds information about an expression while it is being scalarized.  */
217
typedef struct gfc_loopinfo
218
{
219
  stmtblock_t pre;
220
  stmtblock_t post;
221
 
222
  int dimen;
223
 
224
  /* All the SS involved with this loop.  */
225
  gfc_ss *ss;
226
  /* The SS describing the temporary used in an assignment.  */
227
  gfc_ss *temp_ss;
228
 
229
  /* The scalarization loop index variables.  */
230
  tree loopvar[GFC_MAX_DIMENSIONS];
231
 
232
  /* The bounds of the scalarization loops.  */
233
  tree from[GFC_MAX_DIMENSIONS];
234
  tree to[GFC_MAX_DIMENSIONS];
235
  gfc_ss *specloop[GFC_MAX_DIMENSIONS];
236
 
237
  /* The code member contains the code for the body of the next outer loop.  */
238
  stmtblock_t code[GFC_MAX_DIMENSIONS];
239
 
240
  /* Order in which the dimensions should be looped, innermost first.  */
241
  int order[GFC_MAX_DIMENSIONS];
242
 
243
  /* The number of dimensions for which a temporary is used.  */
244
  int temp_dim;
245
 
246
  /* If set we don't need the loop variables.  */
247
  unsigned array_parameter:1;
248
}
249
gfc_loopinfo;
250
 
251
 
252
/* Information about a symbol that has been shadowed by a temporary.  */
253
typedef struct
254
{
255
  symbol_attribute attr;
256
  tree decl;
257
}
258
gfc_saved_var;
259
 
260
 
261
/* Advance the SS chain to the next term.  */
262
void gfc_advance_se_ss_chain (gfc_se *);
263
 
264
/* Call this to initialize a gfc_se structure before use
265
   first parameter is structure to initialize, second is
266
   parent to get scalarization data from, or NULL.  */
267
void gfc_init_se (gfc_se *, gfc_se *);
268
 
269
/* Create an artificial variable decl and add it to the current scope.  */
270
tree gfc_create_var (tree, const char *);
271
/* Like above but doesn't add it to the current scope.  */
272
tree gfc_create_var_np (tree, const char *);
273
 
274
/* Store the result of an expression in a temp variable so it can be used
275
   repeatedly even if the original changes */
276
void gfc_make_safe_expr (gfc_se * se);
277
 
278
/* Makes sure se is suitable for passing as a function string parameter.  */
279
void gfc_conv_string_parameter (gfc_se * se);
280
 
281
/* Compare two strings.  */
282
tree gfc_build_compare_string (tree, tree, tree, tree, int);
283
 
284
/* Add an item to the end of TREE_LIST.  */
285
tree gfc_chainon_list (tree, tree);
286
 
287
/* When using the gfc_conv_* make sure you understand what they do, i.e.
288
   when a POST chain may be created, and what the returned expression may be
289
   used for.  Note that character strings have special handling.  This
290
   should not be a problem as most statements/operations only deal with
291
   numeric/logical types.  See the implementations in trans-expr.c
292
   for details of the individual functions.  */
293
 
294
void gfc_conv_expr (gfc_se * se, gfc_expr * expr);
295
void gfc_conv_expr_val (gfc_se * se, gfc_expr * expr);
296
void gfc_conv_expr_lhs (gfc_se * se, gfc_expr * expr);
297
void gfc_conv_expr_reference (gfc_se * se, gfc_expr *);
298
void gfc_conv_expr_type (gfc_se * se, gfc_expr *, tree);
299
 
300
/* trans-expr.c */
301
void gfc_conv_scalar_char_value (gfc_symbol *sym, gfc_se *se, gfc_expr **expr);
302
 
303
/* Find the decl containing the auxiliary variables for assigned variables.  */
304
void gfc_conv_label_variable (gfc_se * se, gfc_expr * expr);
305
/* If the value is not constant, Create a temporary and copy the value.  */
306
tree gfc_evaluate_now (tree, stmtblock_t *);
307
 
308
/* Intrinsic function handling.  */
309
void gfc_conv_intrinsic_function (gfc_se *, gfc_expr *);
310
 
311
/* Does an intrinsic map directly to an external library call.  */
312
int gfc_is_intrinsic_libcall (gfc_expr *);
313
 
314
/* Used to call ordinary functions/subroutines
315
   and procedure pointer components.  */
316
int gfc_conv_procedure_call (gfc_se *, gfc_symbol *, gfc_actual_arglist *,
317
                            gfc_expr *, tree);
318
 
319
void gfc_conv_subref_array_arg (gfc_se *, gfc_expr *, int, sym_intent, bool);
320
 
321
/* gfc_trans_* shouldn't call push/poplevel, use gfc_push/pop_scope */
322
 
323
/* Generate code for a scalar assignment.  */
324
tree gfc_trans_scalar_assign (gfc_se *, gfc_se *, gfc_typespec, bool, bool);
325
 
326
/* Translate COMMON blocks.  */
327
void gfc_trans_common (gfc_namespace *);
328
 
329
/* Translate a derived type constructor.  */
330
void gfc_conv_structure (gfc_se *, gfc_expr *, int);
331
 
332
/* Return an expression which determines if a dummy parameter is present.  */
333
tree gfc_conv_expr_present (gfc_symbol *);
334
/* Convert a missing, dummy argument into a null or zero.  */
335
void gfc_conv_missing_dummy (gfc_se *, gfc_expr *, gfc_typespec, int);
336
 
337
/* Generate code to allocate a string temporary.  */
338
tree gfc_conv_string_tmp (gfc_se *, tree, tree);
339
/* Get the string length variable belonging to an expression.  */
340
tree gfc_get_expr_charlen (gfc_expr *);
341
/* Initialize a string length variable.  */
342
void gfc_conv_string_length (gfc_charlen *, gfc_expr *, stmtblock_t *);
343
/* Ensure type sizes can be gimplified.  */
344
void gfc_trans_vla_type_sizes (gfc_symbol *, stmtblock_t *);
345
 
346
/* Add an expression to the end of a block.  */
347
void gfc_add_expr_to_block (stmtblock_t *, tree);
348
/* Add a block to the end of a block.  */
349
void gfc_add_block_to_block (stmtblock_t *, stmtblock_t *);
350
/* Add a MODIFY_EXPR to a block.  */
351
void gfc_add_modify (stmtblock_t *, tree, tree);
352
 
353
/* Initialize a statement block.  */
354
void gfc_init_block (stmtblock_t *);
355
/* Start a new statement block.  Like gfc_init_block but also starts a new
356
   variable scope.  */
357
void gfc_start_block (stmtblock_t *);
358
/* Finish a statement block.  Also closes the scope if the block was created
359
   with gfc_start_block.  */
360
tree gfc_finish_block (stmtblock_t *);
361
/* Merge the scope of a block with its parent.  */
362
void gfc_merge_block_scope (stmtblock_t * block);
363
 
364
/* Return the backend label decl.  */
365
tree gfc_get_label_decl (gfc_st_label *);
366
 
367
/* Return the decl for an external function.  */
368
tree gfc_get_extern_function_decl (gfc_symbol *);
369
 
370
/* Return the decl for a function.  */
371
tree gfc_get_function_decl (gfc_symbol *);
372
 
373
/* Build an ADDR_EXPR.  */
374
tree gfc_build_addr_expr (tree, tree);
375
 
376
/* Build an ARRAY_REF.  */
377
tree gfc_build_array_ref (tree, tree, tree);
378
 
379
/* Creates a label.  Decl is artificial if label_id == NULL_TREE.  */
380
tree gfc_build_label_decl (tree);
381
 
382
/* Return the decl used to hold the function return value.
383
   Do not use if the function has an explicit result variable.  */
384
tree gfc_get_fake_result_decl (gfc_symbol *, int);
385
 
386
/* Get the return label for the current function.  */
387
tree gfc_get_return_label (void);
388
 
389
/* Add a decl to the binding level for the current function.  */
390
void gfc_add_decl_to_function (tree);
391
 
392
/* Make prototypes for runtime library functions.  */
393
void gfc_build_builtin_function_decls (void);
394
 
395
/* Set the backend source location of a decl.  */
396
void gfc_set_decl_location (tree, locus *);
397
 
398
/* Return the variable decl for a symbol.  */
399
tree gfc_get_symbol_decl (gfc_symbol *);
400
 
401
/* Build a static initializer.  */
402
tree gfc_conv_initializer (gfc_expr *, gfc_typespec *, tree, bool, bool);
403
 
404
/* Assign a default initializer to a derived type.  */
405
tree gfc_init_default_dt (gfc_symbol *, tree);
406
 
407
/* Substitute a temporary variable in place of the real one.  */
408
void gfc_shadow_sym (gfc_symbol *, tree, gfc_saved_var *);
409
 
410
/* Restore the original variable.  */
411
void gfc_restore_sym (gfc_symbol *, gfc_saved_var *);
412
 
413
/* Setting a decl assembler name, mangling it according to target rules
414
   (like Windows @NN decorations).  */
415
void gfc_set_decl_assembler_name (tree, tree);
416
 
417
/* Returns true if a variable of specified size should go on the stack.  */
418
int gfc_can_put_var_on_stack (tree);
419
 
420
/* Allocate the lang-specific part of a decl node.  */
421
void gfc_allocate_lang_decl (tree);
422
 
423
/* Advance along a TREE_CHAIN.  */
424
tree gfc_advance_chain (tree, int);
425
 
426
/* Create a decl for a function.  */
427
void gfc_create_function_decl (gfc_namespace *);
428
/* Generate the code for a function.  */
429
void gfc_generate_function_code (gfc_namespace *);
430
/* Output a BLOCK DATA program unit.  */
431
void gfc_generate_block_data (gfc_namespace *);
432
/* Output a decl for a module variable.  */
433
void gfc_generate_module_vars (gfc_namespace *);
434
 
435
struct GTY(()) module_htab_entry {
436
  const char *name;
437
  tree namespace_decl;
438
  htab_t GTY ((param_is (union tree_node))) decls;
439
};
440
 
441
struct module_htab_entry *gfc_find_module (const char *);
442
void gfc_module_add_decl (struct module_htab_entry *, tree);
443
 
444
/* Get and set the current location.  */
445
void gfc_set_backend_locus (locus *);
446
void gfc_get_backend_locus (locus *);
447
 
448
/* Handle static constructor functions.  */
449
extern GTY(()) tree gfc_static_ctors;
450
void gfc_generate_constructors (void);
451
 
452
/* Get the string length of an array constructor.  */
453
bool get_array_ctor_strlen (stmtblock_t *, gfc_constructor *, tree *);
454
 
455
/* Generate a runtime error call.  */
456
tree gfc_trans_runtime_error (bool, locus*, const char*, ...);
457
tree gfc_trans_runtime_error_vararg (bool, locus*, const char*, va_list);
458
 
459
/* Generate a runtime warning/error check.  */
460
void gfc_trans_runtime_check (bool, bool, tree, stmtblock_t *, locus *,
461
                              const char *, ...);
462
 
463
/* Generate a runtime check for same string length.  */
464
void gfc_trans_same_strlen_check (const char*, locus*, tree, tree,
465
                                  stmtblock_t*);
466
 
467
/* Generate a call to free() after checking that its arg is non-NULL.  */
468
tree gfc_call_free (tree);
469
 
470
/* Allocate memory after performing a few checks.  */
471
tree gfc_call_malloc (stmtblock_t *, tree, tree);
472
 
473
/* Build a memcpy call.  */
474
tree gfc_build_memcpy_call (tree, tree, tree);
475
 
476
/* Allocate memory for arrays, with optional status variable.  */
477
tree gfc_allocate_array_with_status (stmtblock_t*, tree, tree, tree, gfc_expr*);
478
 
479
/* Allocate memory, with optional status variable.  */
480
tree gfc_allocate_with_status (stmtblock_t *, tree, tree);
481
 
482
/* Generate code to deallocate an array.  */
483
tree gfc_deallocate_with_status (tree, tree, bool, gfc_expr*);
484
 
485
/* Generate code to call realloc().  */
486
tree gfc_call_realloc (stmtblock_t *, tree, tree);
487
 
488
/* Generate code for an assignment, includes scalarization.  */
489
tree gfc_trans_assignment (gfc_expr *, gfc_expr *, bool);
490
 
491
/* Generate code for a pointer assignment.  */
492
tree gfc_trans_pointer_assignment (gfc_expr *, gfc_expr *);
493
 
494
/* Initialize function decls for library functions.  */
495
void gfc_build_intrinsic_lib_fndecls (void);
496
/* Create function decls for IO library functions.  */
497
void gfc_trans_io_runtime_check (tree, tree, int, const char *, stmtblock_t *);
498
void gfc_build_io_library_fndecls (void);
499
/* Build a function decl for a library function.  */
500
tree gfc_build_library_function_decl (tree, tree, int, ...);
501
 
502
/* Process the local variable decls of a block construct.  */
503
void gfc_process_block_locals (gfc_namespace*);
504
 
505
/* Output initialization/clean-up code that was deferred.  */
506
tree gfc_trans_deferred_vars (gfc_symbol*, tree);
507
 
508
/* somewhere! */
509
tree pushdecl (tree);
510
tree pushdecl_top_level (tree);
511
void pushlevel (int);
512
tree poplevel (int, int, int);
513
tree getdecls (void);
514
tree gfc_truthvalue_conversion (tree);
515
tree gfc_builtin_function (tree);
516
struct array_descr_info;
517
bool gfc_get_array_descr_info (const_tree, struct array_descr_info *);
518
 
519
/* In trans-openmp.c */
520
bool gfc_omp_privatize_by_reference (const_tree);
521
enum omp_clause_default_kind gfc_omp_predetermined_sharing (tree);
522
tree gfc_omp_report_decl (tree);
523
tree gfc_omp_clause_default_ctor (tree, tree, tree);
524
tree gfc_omp_clause_copy_ctor (tree, tree, tree);
525
tree gfc_omp_clause_assign_op (tree, tree, tree);
526
tree gfc_omp_clause_dtor (tree, tree);
527
bool gfc_omp_disregard_value_expr (tree, bool);
528
bool gfc_omp_private_debug_clause (tree, bool);
529
bool gfc_omp_private_outer_ref (tree);
530
struct gimplify_omp_ctx;
531
void gfc_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *, tree);
532
 
533
/* Runtime library function decls.  */
534
extern GTY(()) tree gfor_fndecl_pause_numeric;
535
extern GTY(()) tree gfor_fndecl_pause_string;
536
extern GTY(()) tree gfor_fndecl_stop_numeric;
537
extern GTY(()) tree gfor_fndecl_stop_string;
538
extern GTY(()) tree gfor_fndecl_runtime_error;
539
extern GTY(()) tree gfor_fndecl_runtime_error_at;
540
extern GTY(()) tree gfor_fndecl_runtime_warning_at;
541
extern GTY(()) tree gfor_fndecl_os_error;
542
extern GTY(()) tree gfor_fndecl_generate_error;
543
extern GTY(()) tree gfor_fndecl_set_fpe;
544
extern GTY(()) tree gfor_fndecl_set_options;
545
extern GTY(()) tree gfor_fndecl_ttynam;
546
extern GTY(()) tree gfor_fndecl_ctime;
547
extern GTY(()) tree gfor_fndecl_fdate;
548
extern GTY(()) tree gfor_fndecl_in_pack;
549
extern GTY(()) tree gfor_fndecl_in_unpack;
550
extern GTY(()) tree gfor_fndecl_associated;
551
 
552
/* Math functions.  Many other math functions are handled in
553
   trans-intrinsic.c.  */
554
 
555
typedef struct GTY(()) gfc_powdecl_list {
556
  tree integer;
557
  tree real;
558
  tree cmplx;
559
}
560
gfc_powdecl_list;
561
 
562
extern GTY(()) gfc_powdecl_list gfor_fndecl_math_powi[4][3];
563
extern GTY(()) tree gfor_fndecl_math_ishftc4;
564
extern GTY(()) tree gfor_fndecl_math_ishftc8;
565
extern GTY(()) tree gfor_fndecl_math_ishftc16;
566
 
567
/* BLAS functions.  */
568
extern GTY(()) tree gfor_fndecl_sgemm;
569
extern GTY(()) tree gfor_fndecl_dgemm;
570
extern GTY(()) tree gfor_fndecl_cgemm;
571
extern GTY(()) tree gfor_fndecl_zgemm;
572
 
573
/* String functions.  */
574
extern GTY(()) tree gfor_fndecl_compare_string;
575
extern GTY(()) tree gfor_fndecl_concat_string;
576
extern GTY(()) tree gfor_fndecl_string_len_trim;
577
extern GTY(()) tree gfor_fndecl_string_index;
578
extern GTY(()) tree gfor_fndecl_string_scan;
579
extern GTY(()) tree gfor_fndecl_string_verify;
580
extern GTY(()) tree gfor_fndecl_string_trim;
581
extern GTY(()) tree gfor_fndecl_string_minmax;
582
extern GTY(()) tree gfor_fndecl_adjustl;
583
extern GTY(()) tree gfor_fndecl_adjustr;
584
extern GTY(()) tree gfor_fndecl_select_string;
585
extern GTY(()) tree gfor_fndecl_compare_string_char4;
586
extern GTY(()) tree gfor_fndecl_concat_string_char4;
587
extern GTY(()) tree gfor_fndecl_string_len_trim_char4;
588
extern GTY(()) tree gfor_fndecl_string_index_char4;
589
extern GTY(()) tree gfor_fndecl_string_scan_char4;
590
extern GTY(()) tree gfor_fndecl_string_verify_char4;
591
extern GTY(()) tree gfor_fndecl_string_trim_char4;
592
extern GTY(()) tree gfor_fndecl_string_minmax_char4;
593
extern GTY(()) tree gfor_fndecl_adjustl_char4;
594
extern GTY(()) tree gfor_fndecl_adjustr_char4;
595
extern GTY(()) tree gfor_fndecl_select_string_char4;
596
 
597
/* Conversion between character kinds.  */
598
extern GTY(()) tree gfor_fndecl_convert_char1_to_char4;
599
extern GTY(()) tree gfor_fndecl_convert_char4_to_char1;
600
 
601
/* Other misc. runtime library functions.  */
602
extern GTY(()) tree gfor_fndecl_size0;
603
extern GTY(()) tree gfor_fndecl_size1;
604
extern GTY(()) tree gfor_fndecl_iargc;
605
extern GTY(()) tree gfor_fndecl_clz128;
606
extern GTY(()) tree gfor_fndecl_ctz128;
607
 
608
/* Implemented in Fortran.  */
609
extern GTY(()) tree gfor_fndecl_sc_kind;
610
extern GTY(()) tree gfor_fndecl_si_kind;
611
extern GTY(()) tree gfor_fndecl_sr_kind;
612
 
613
 
614
/* True if node is an integer constant.  */
615
#define INTEGER_CST_P(node) (TREE_CODE(node) == INTEGER_CST)
616
 
617
/* G95-specific declaration information.  */
618
 
619
enum gfc_array_kind
620
{
621
  GFC_ARRAY_UNKNOWN,
622
  GFC_ARRAY_ASSUMED_SHAPE,
623
  GFC_ARRAY_ALLOCATABLE,
624
  GFC_ARRAY_POINTER
625
};
626
 
627
/* Array types only.  */
628
struct GTY(())  lang_type        {
629
  int rank;
630
  enum gfc_array_kind akind;
631
  tree lbound[GFC_MAX_DIMENSIONS];
632
  tree ubound[GFC_MAX_DIMENSIONS];
633
  tree stride[GFC_MAX_DIMENSIONS];
634
  tree size;
635
  tree offset;
636
  tree dtype;
637
  tree dataptr_type;
638
  tree span;
639
  tree base_decl[2];
640
};
641
 
642
struct GTY(()) lang_decl {
643
  /* Dummy variables.  */
644
  tree saved_descriptor;
645
  /* Assigned integer nodes.  Stringlength is the IO format string's length.
646
     Addr is the address of the string or the target label. Stringlength is
647
     initialized to -2 and assigned to -1 when addr is assigned to the
648
     address of target label.  */
649
  tree stringlen;
650
  tree addr;
651
  tree span;
652
};
653
 
654
 
655
#define GFC_DECL_ASSIGN_ADDR(node) DECL_LANG_SPECIFIC(node)->addr
656
#define GFC_DECL_STRING_LEN(node) DECL_LANG_SPECIFIC(node)->stringlen
657
#define GFC_DECL_SPAN(node) DECL_LANG_SPECIFIC(node)->span
658
#define GFC_DECL_SAVED_DESCRIPTOR(node) \
659
  (DECL_LANG_SPECIFIC(node)->saved_descriptor)
660
#define GFC_DECL_PACKED_ARRAY(node) DECL_LANG_FLAG_0(node)
661
#define GFC_DECL_PARTIAL_PACKED_ARRAY(node) DECL_LANG_FLAG_1(node)
662
#define GFC_DECL_ASSIGN(node) DECL_LANG_FLAG_2(node)
663
#define GFC_DECL_COMMON_OR_EQUIV(node) DECL_LANG_FLAG_3(node)
664
#define GFC_DECL_CRAY_POINTEE(node) DECL_LANG_FLAG_4(node)
665
#define GFC_DECL_RESULT(node) DECL_LANG_FLAG_5(node)
666
#define GFC_DECL_SUBREF_ARRAY_P(node) DECL_LANG_FLAG_6(node)
667
 
668
/* An array descriptor.  */
669
#define GFC_DESCRIPTOR_TYPE_P(node) TYPE_LANG_FLAG_1(node)
670
/* An array without a descriptor.  */
671
#define GFC_ARRAY_TYPE_P(node) TYPE_LANG_FLAG_2(node)
672
/* Fortran POINTER type.  */
673
#define GFC_POINTER_TYPE_P(node) TYPE_LANG_FLAG_3(node)
674
/* The GFC_TYPE_ARRAY_* members are present in both descriptor and
675
   descriptorless array types.  */
676
#define GFC_TYPE_ARRAY_LBOUND(node, dim) \
677
  (TYPE_LANG_SPECIFIC(node)->lbound[dim])
678
#define GFC_TYPE_ARRAY_UBOUND(node, dim) \
679
  (TYPE_LANG_SPECIFIC(node)->ubound[dim])
680
#define GFC_TYPE_ARRAY_STRIDE(node, dim) \
681
  (TYPE_LANG_SPECIFIC(node)->stride[dim])
682
#define GFC_TYPE_ARRAY_RANK(node) (TYPE_LANG_SPECIFIC(node)->rank)
683
#define GFC_TYPE_ARRAY_SIZE(node) (TYPE_LANG_SPECIFIC(node)->size)
684
#define GFC_TYPE_ARRAY_OFFSET(node) (TYPE_LANG_SPECIFIC(node)->offset)
685
#define GFC_TYPE_ARRAY_AKIND(node) (TYPE_LANG_SPECIFIC(node)->akind)
686
/* Code should use gfc_get_dtype instead of accessing this directly.  It may
687
   not be known when the type is created.  */
688
#define GFC_TYPE_ARRAY_DTYPE(node) (TYPE_LANG_SPECIFIC(node)->dtype)
689
#define GFC_TYPE_ARRAY_DATAPTR_TYPE(node) \
690
  (TYPE_LANG_SPECIFIC(node)->dataptr_type)
691
#define GFC_TYPE_ARRAY_SPAN(node) (TYPE_LANG_SPECIFIC(node)->span)
692
#define GFC_TYPE_ARRAY_BASE_DECL(node, internal) \
693
  (TYPE_LANG_SPECIFIC(node)->base_decl[(internal)])
694
 
695
/* Build an expression with void type.  */
696
#define build1_v(code, arg) fold_build1(code, void_type_node, arg)
697
#define build2_v(code, arg1, arg2) fold_build2(code, void_type_node, \
698
                                               arg1, arg2)
699
#define build3_v(code, arg1, arg2, arg3) fold_build3(code, void_type_node, \
700
                                                     arg1, arg2, arg3)
701
#define build4_v(code, arg1, arg2, arg3, arg4) build4(code, void_type_node, \
702
                                                      arg1, arg2, arg3, arg4)
703
 
704
/* This group of functions allows a caller to evaluate an expression from
705
   the callee's interface.  It establishes a mapping between the interface's
706
   dummy arguments and the caller's actual arguments, then applies that
707
   mapping to a given gfc_expr.
708
 
709
   You can initialize a mapping structure like so:
710
 
711
       gfc_interface_mapping mapping;
712
       ...
713
       gfc_init_interface_mapping (&mapping);
714
 
715
   You should then evaluate each actual argument into a temporary
716
   gfc_se structure, here called "se", and map the result to the
717
   dummy argument's symbol, here called "sym":
718
 
719
       gfc_add_interface_mapping (&mapping, sym, &se);
720
 
721
   After adding all mappings, you should call:
722
 
723
       gfc_finish_interface_mapping (&mapping, pre, post);
724
 
725
   where "pre" and "post" are statement blocks for initialization
726
   and finalization code respectively.  You can then evaluate an
727
   interface expression "expr" as follows:
728
 
729
       gfc_apply_interface_mapping (&mapping, se, expr);
730
 
731
   Once you've evaluated all expressions, you should free
732
   the mapping structure with:
733
 
734
       gfc_free_interface_mapping (&mapping); */
735
 
736
 
737
/* This structure represents a mapping from OLD to NEW, where OLD is a
738
   dummy argument symbol and NEW is a symbol that represents the value
739
   of an actual argument.  Mappings are linked together using NEXT
740
   (in no particular order).  */
741
typedef struct gfc_interface_sym_mapping
742
{
743
  struct gfc_interface_sym_mapping *next;
744
  gfc_symbol *old;
745
  gfc_symtree *new_sym;
746
  gfc_expr *expr;
747
}
748
gfc_interface_sym_mapping;
749
 
750
 
751
/* This structure is used by callers to evaluate an expression from
752
   a callee's interface.  */
753
typedef struct gfc_interface_mapping
754
{
755
  /* Maps the interface's dummy arguments to the values that the caller
756
     is passing.  The whole list is owned by this gfc_interface_mapping.  */
757
  gfc_interface_sym_mapping *syms;
758
 
759
  /* A list of gfc_charlens that were needed when creating copies of
760
     expressions.  The whole list is owned by this gfc_interface_mapping.  */
761
  gfc_charlen *charlens;
762
}
763
gfc_interface_mapping;
764
 
765
void gfc_init_interface_mapping (gfc_interface_mapping *);
766
void gfc_free_interface_mapping (gfc_interface_mapping *);
767
void gfc_add_interface_mapping (gfc_interface_mapping *,
768
                                gfc_symbol *, gfc_se *, gfc_expr *);
769
void gfc_finish_interface_mapping (gfc_interface_mapping *,
770
                                   stmtblock_t *, stmtblock_t *);
771
void gfc_apply_interface_mapping (gfc_interface_mapping *,
772
                                  gfc_se *, gfc_expr *);
773
 
774
 
775
/* Standard error messages used in all the trans-*.c files.  */
776
extern const char gfc_msg_fault[];
777
extern const char gfc_msg_wrong_return[];
778
 
779
#define OMPWS_WORKSHARE_FLAG    1       /* Set if in a workshare construct.  */
780
#define OMPWS_CURR_SINGLEUNIT   2       /* Set if current gfc_code in workshare
781
                                           construct is not workshared.  */
782
#define OMPWS_SCALARIZER_WS     4       /* Set if scalarizer should attempt
783
                                           to create parallel loops.  */
784
#define OMPWS_NOWAIT            8       /* Use NOWAIT on OMP_FOR.  */
785
extern int ompws_flags;
786
 
787
#endif /* GFC_TRANS_H */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.