gcc/fortran/st.c

   1 /* Build executable statement trees.
   2    Copyright (C) 2000-2015 Free Software Foundation, Inc.
   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 /* Executable statements are strung together into a singly linked list
  22    of code structures.  These structures are later translated into GCC
  23    GENERIC tree structures and from there to executable code for a
  24    target.  */
  25
  26 #include "config.h"
  27 #include "system.h"
  28 #include "coretypes.h"
  29 #include "gfortran.h"
  30
  31 gfc_code new_st;
  32
  33
  34 /* Zeroes out the new_st structure.  */
  35
  36 void
  37 gfc_clear_new_st (void)
  38 {
  39   memset (&new_st, '\0', sizeof (new_st));
  40   new_st.op = EXEC_NOP;
  41 }
  42
  43
  44 /* Get a gfc_code structure, initialized with the current locus
  45    and a statement code 'op'.  */
  46
  47 gfc_code *
  48 gfc_get_code (gfc_exec_op op)
  49 {
  50   gfc_code *c;
  51
  52   c = XCNEW (gfc_code);
  53   c->op = op;
  54   c->loc = gfc_current_locus;
  55   return c;
  56 }
  57
  58
  59 /* Given some part of a gfc_code structure, append a set of code to
  60    its tail, returning a pointer to the new tail.  */
  61
  62 gfc_code *
  63 gfc_append_code (gfc_code *tail, gfc_code *new_code)
  64 {
  65   if (tail != NULL)
  66     {
  67       while (tail->next != NULL)
  68         tail = tail->next;
  69
  70       tail->next = new_code;
  71     }
  72
  73   while (new_code->next != NULL)
  74     new_code = new_code->next;
  75
  76   return new_code;
  77 }
  78
  79
  80 /* Free a single code structure, but not the actual structure itself.  */
  81
  82 void
  83 gfc_free_statement (gfc_code *p)
  84 {
  85   if (p->expr1)
  86     gfc_free_expr (p->expr1);
  87   if (p->expr2)
  88     gfc_free_expr (p->expr2);
  89
  90   switch (p->op)
  91     {
  92     case EXEC_NOP:
  93     case EXEC_END_BLOCK:
  94     case EXEC_END_NESTED_BLOCK:
  95     case EXEC_ASSIGN:
  96     case EXEC_INIT_ASSIGN:
  97     case EXEC_GOTO:
  98     case EXEC_CYCLE:
  99     case EXEC_RETURN:
 100     case EXEC_END_PROCEDURE:
 101     case EXEC_IF:
 102     case EXEC_PAUSE:
 103     case EXEC_STOP:
 104     case EXEC_ERROR_STOP:
 105     case EXEC_EXIT:
 106     case EXEC_WHERE:
 107     case EXEC_IOLENGTH:
 108     case EXEC_POINTER_ASSIGN:
 109     case EXEC_DO_WHILE:
 110     case EXEC_CONTINUE:
 111     case EXEC_TRANSFER:
 112     case EXEC_LABEL_ASSIGN:
 113     case EXEC_ENTRY:
 114     case EXEC_ARITHMETIC_IF:
 115     case EXEC_CRITICAL:
 116     case EXEC_SYNC_ALL:
 117     case EXEC_SYNC_IMAGES:
 118     case EXEC_SYNC_MEMORY:
 119     case EXEC_LOCK:
 120     case EXEC_UNLOCK:
 121       break;
 122
 123     case EXEC_BLOCK:
 124       gfc_free_namespace (p->ext.block.ns);
 125       gfc_free_association_list (p->ext.block.assoc);
 126       break;
 127
 128     case EXEC_COMPCALL:
 129     case EXEC_CALL_PPC:
 130     case EXEC_CALL:
 131     case EXEC_ASSIGN_CALL:
 132       gfc_free_actual_arglist (p->ext.actual);
 133       break;
 134
 135     case EXEC_SELECT:
 136     case EXEC_SELECT_TYPE:
 137       if (p->ext.block.case_list)
 138         gfc_free_case_list (p->ext.block.case_list);
 139       break;
 140
 141     case EXEC_DO:
 142       gfc_free_iterator (p->ext.iterator, 1);
 143       break;
 144
 145     case EXEC_ALLOCATE:
 146     case EXEC_DEALLOCATE:
 147       gfc_free_alloc_list (p->ext.alloc.list);
 148       break;
 149
 150     case EXEC_OPEN:
 151       gfc_free_open (p->ext.open);
 152       break;
 153
 154     case EXEC_CLOSE:
 155       gfc_free_close (p->ext.close);
 156       break;
 157
 158     case EXEC_BACKSPACE:
 159     case EXEC_ENDFILE:
 160     case EXEC_REWIND:
 161     case EXEC_FLUSH:
 162       gfc_free_filepos (p->ext.filepos);
 163       break;
 164
 165     case EXEC_INQUIRE:
 166       gfc_free_inquire (p->ext.inquire);
 167       break;
 168
 169     case EXEC_WAIT:
 170       gfc_free_wait (p->ext.wait);
 171       break;
 172
 173     case EXEC_READ:
 174     case EXEC_WRITE:
 175       gfc_free_dt (p->ext.dt);
 176       break;
 177
 178     case EXEC_DT_END:
 179       /* The ext.dt member is a duplicate pointer and doesn't need to
 180          be freed.  */
 181       break;
 182
 183     case EXEC_DO_CONCURRENT:
 184     case EXEC_FORALL:
 185       gfc_free_forall_iterator (p->ext.forall_iterator);
 186       break;
 187
 188     case EXEC_OACC_PARALLEL_LOOP:
 189     case EXEC_OACC_PARALLEL:
 190     case EXEC_OACC_KERNELS_LOOP:
 191     case EXEC_OACC_KERNELS:
 192     case EXEC_OACC_DATA:
 193     case EXEC_OACC_HOST_DATA:
 194     case EXEC_OACC_LOOP:
 195     case EXEC_OACC_UPDATE:
 196     case EXEC_OACC_WAIT:
 197     case EXEC_OACC_CACHE:
 198     case EXEC_OACC_ENTER_DATA:
 199     case EXEC_OACC_EXIT_DATA:
 200     case EXEC_OMP_CANCEL:
 201     case EXEC_OMP_CANCELLATION_POINT:
 202     case EXEC_OMP_DISTRIBUTE:
 203     case EXEC_OMP_DISTRIBUTE_PARALLEL_DO:
 204     case EXEC_OMP_DISTRIBUTE_PARALLEL_DO_SIMD:
 205     case EXEC_OMP_DISTRIBUTE_SIMD:
 206     case EXEC_OMP_DO:
 207     case EXEC_OMP_DO_SIMD:
 208     case EXEC_OMP_END_SINGLE:
 209     case EXEC_OMP_PARALLEL:
 210     case EXEC_OMP_PARALLEL_DO:
 211     case EXEC_OMP_PARALLEL_DO_SIMD:
 212     case EXEC_OMP_PARALLEL_SECTIONS:
 213     case EXEC_OMP_SECTIONS:
 214     case EXEC_OMP_SIMD:
 215     case EXEC_OMP_SINGLE:
 216     case EXEC_OMP_TARGET:
 217     case EXEC_OMP_TARGET_DATA:
 218     case EXEC_OMP_TARGET_TEAMS:
 219     case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE:
 220     case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO:
 221     case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD:
 222     case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD:
 223     case EXEC_OMP_TARGET_UPDATE:
 224     case EXEC_OMP_TASK:
 225     case EXEC_OMP_TEAMS:
 226     case EXEC_OMP_TEAMS_DISTRIBUTE:
 227     case EXEC_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO:
 228     case EXEC_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD:
 229     case EXEC_OMP_TEAMS_DISTRIBUTE_SIMD:
 230     case EXEC_OMP_WORKSHARE:
 231     case EXEC_OMP_PARALLEL_WORKSHARE:
 232       gfc_free_omp_clauses (p->ext.omp_clauses);
 233       break;
 234
 235     case EXEC_OMP_CRITICAL:
 236       free (CONST_CAST (char *, p->ext.omp_name));
 237       break;
 238
 239     case EXEC_OMP_FLUSH:
 240       gfc_free_omp_namelist (p->ext.omp_namelist);
 241       break;
 242
 243     case EXEC_OMP_ATOMIC:
 244     case EXEC_OMP_BARRIER:
 245     case EXEC_OMP_MASTER:
 246     case EXEC_OMP_ORDERED:
 247     case EXEC_OMP_END_NOWAIT:
 248     case EXEC_OMP_TASKGROUP:
 249     case EXEC_OMP_TASKWAIT:
 250     case EXEC_OMP_TASKYIELD:
 251       break;
 252
 253     default:
 254       gfc_internal_error ("gfc_free_statement(): Bad statement");
 255     }
 256 }
 257
 258
 259 /* Free a code statement and all other code structures linked to it.  */
 260
 261 void
 262 gfc_free_statements (gfc_code *p)
 263 {
 264   gfc_code *q;
 265
 266   for (; p; p = q)
 267     {
 268       q = p->next;
 269
 270       if (p->block)
 271         gfc_free_statements (p->block);
 272       gfc_free_statement (p);
 273       free (p);
 274     }
 275 }
 276
 277
 278 /* Free an association list (of an ASSOCIATE statement).  */
 279
 280 void
 281 gfc_free_association_list (gfc_association_list* assoc)
 282 {
 283   if (!assoc)
 284     return;
 285
 286   gfc_free_association_list (assoc->next);
 287   free (assoc);
 288 }