gcc/fortran/trans.h

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