gcc/c-iterate.c

   1 /* Build expressions with type checking for C compiler.
   2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996
   3    1997, 1998, 2000 Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  23 /* This file is part of the C front end.
  24    It is responsible for implementing iterators,
  25    both their declarations and the expansion of statements using them.  */
  26
  27 #include "config.h"
  28 #include "system.h"
  29 #include "tree.h"
  30 #include "c-tree.h"
  31 #include "flags.h"
  32 #include "obstack.h"
  33 #include "rtl.h"
  34 #include "toplev.h"
  35 #include "expr.h"
  36 \f
  37 /*
  38                 KEEPING TRACK OF EXPANSIONS
  39
  40    In order to clean out expansions corresponding to statements inside
  41    "{(...)}" constructs we have to keep track of all expansions.  The
  42    cleanup is needed when an automatic, or implicit, expansion on
  43    iterator, say X, happens to a statement which contains a {(...)}
  44    form with a statement already expanded on X.  In this case we have
  45    to go back and cleanup the inner expansion.  This can be further
  46    complicated by the fact that {(...)} can be nested.
  47
  48    To make this cleanup possible, we keep lists of all expansions, and
  49    to make it work for nested constructs, we keep a stack.  The list at
  50    the top of the stack (ITER_STACK.CURRENT_LEVEL) corresponds to the
  51    currently parsed level.  All expansions of the levels below the
  52    current one are kept in one list whose head is pointed to by
  53    ITER_STACK.SUBLEVEL_FIRST (SUBLEVEL_LAST is there for making merges
  54    easy).  The process works as follows:
  55
  56    -- On "({"  a new node is added to the stack by PUSH_ITERATOR_STACK.
  57                The sublevel list is not changed at this point.
  58
  59    -- On "})" the list for the current level is appended to the sublevel
  60               list.
  61
  62    -- On ";"  sublevel lists are appended to the current level lists.
  63               The reason is this: if they have not been superseded by the
  64               expansion at the current level, they still might be
  65               superseded later by the expansion on the higher level.
  66               The levels do not have to distinguish levels below, so we
  67               can merge the lists together.  */
  68
  69 struct  ixpansion
  70 {
  71   tree ixdecl;                  /* Iterator decl */
  72   rtx  ixprologue_start;        /* First insn of epilogue. NULL means */
  73   /* explicit (FOR) expansion*/
  74   rtx  ixprologue_end;
  75   rtx  ixepilogue_start;
  76   rtx  ixepilogue_end;
  77   struct ixpansion *next;       /* Next in the list */
  78 };
  79
  80 struct iter_stack_node
  81 {
  82   struct ixpansion *first;      /* Head of list of ixpansions */
  83   struct ixpansion *last;       /* Last node in list  of ixpansions */
  84   struct iter_stack_node *next; /* Next level iterator stack node  */
  85 };
  86
  87 struct iter_stack_node *iter_stack;
  88 struct iter_stack_node sublevel_ixpansions;
  89
  90 /* A special obstack, and a pointer to the start of
  91    all the data in it (so we can free everything easily).  */
  92 static struct obstack ixp_obstack;
  93 static char *ixp_firstobj;
  94
  95 /* During collect_iterators, a list of SAVE_EXPRs already scanned.  */
  96 static tree save_exprs;
  97
  98 static void expand_stmt_with_iterators_1 PARAMS ((tree, tree));
  99 static tree collect_iterators           PARAMS ((tree, tree));
 100 static void iterator_loop_prologue      PARAMS ((tree, rtx *, rtx *));
 101 static void iterator_loop_epilogue      PARAMS ((tree, rtx *, rtx *));
 102 static int top_level_ixpansion_p        PARAMS ((void));
 103 static void isn_append                  PARAMS ((struct iter_stack_node *,
 104                                                  struct iter_stack_node *));
 105 static void istack_sublevel_to_current  PARAMS ((void));
 106 static void add_ixpansion               PARAMS ((tree, rtx, rtx, rtx, rtx));
 107 static void delete_ixpansion            PARAMS ((tree));
 108 \f
 109 /* Initialize our obstack once per compilation.  */
 110
 111 void
 112 init_iterators ()
 113 {
 114   gcc_obstack_init (&ixp_obstack);
 115   ixp_firstobj = (char *) obstack_alloc (&ixp_obstack, 0);
 116 }
 117
 118 /* Handle the start of an explicit `for' loop for iterator IDECL.  */
 119
 120 void
 121 iterator_for_loop_start (idecl)
 122      tree idecl;
 123 {
 124   ITERATOR_BOUND_P (idecl) = 1;
 125   add_ixpansion (idecl, 0, 0, 0, 0);
 126   iterator_loop_prologue (idecl, 0, 0);
 127 }
 128
 129 /* Handle the end of an explicit `for' loop for iterator IDECL.  */
 130
 131 void
 132 iterator_for_loop_end (idecl)
 133      tree idecl;
 134 {
 135   iterator_loop_epilogue (idecl, 0, 0);
 136   ITERATOR_BOUND_P (idecl) = 0;
 137 }
 138 \f
 139 /*
 140                 ITERATOR RTL EXPANSIONS
 141
 142    Expanding simple statements with iterators is straightforward:
 143    collect the list of all free iterators in the statement, and
 144    generate a loop for each of them.
 145
 146    An iterator is "free" if it has not been "bound" by a FOR
 147    operator.  The DECL_RTL of the iterator is the loop counter.  */
 148
 149 /* Expand a statement STMT, possibly containing iterator usage, into RTL.  */
 150
 151 void
 152 iterator_expand (stmt)
 153     tree stmt;
 154 {
 155   tree iter_list;
 156   save_exprs = NULL_TREE;
 157   iter_list = collect_iterators (stmt, NULL_TREE);
 158   expand_stmt_with_iterators_1 (stmt, iter_list);
 159   istack_sublevel_to_current ();
 160 }
 161
 162
 163 static void
 164 expand_stmt_with_iterators_1 (stmt, iter_list)
 165      tree stmt, iter_list;
 166 {
 167   if (iter_list == 0)
 168     expand_expr_stmt (stmt);
 169   else
 170     {
 171       tree current_iterator = TREE_VALUE (iter_list);
 172       tree iter_list_tail   = TREE_CHAIN (iter_list);
 173       rtx p_start, p_end, e_start, e_end;
 174
 175       iterator_loop_prologue (current_iterator, &p_start, &p_end);
 176       expand_stmt_with_iterators_1 (stmt, iter_list_tail);
 177       iterator_loop_epilogue (current_iterator, &e_start, &e_end);
 178
 179       /** Delete all inner expansions based on current_iterator **/
 180       /** before adding the outer one. **/
 181
 182       delete_ixpansion (current_iterator);
 183       add_ixpansion (current_iterator, p_start, p_end, e_start, e_end);
 184     }
 185 }
 186
 187
 188 /* Return a list containing all the free (i.e. not bound by a
 189    containing `for' statement) iterators mentioned in EXP, plus those
 190    in LIST.  Do not add duplicate entries to the list.  */
 191
 192 static tree
 193 collect_iterators (exp, list)
 194      tree exp, list;
 195 {
 196   if (exp == 0) return list;
 197
 198   switch (TREE_CODE (exp))
 199     {
 200     case VAR_DECL:
 201       if (! ITERATOR_P (exp) || ITERATOR_BOUND_P (exp))
 202         return list;
 203       if (value_member (exp, list))
 204         return list;
 205       return tree_cons (NULL_TREE, exp, list);
 206
 207     case TREE_LIST:
 208       {
 209         tree tail;
 210         for (tail = exp; tail; tail = TREE_CHAIN (tail))
 211           list = collect_iterators (TREE_VALUE (tail), list);
 212         return list;
 213       }
 214
 215     case SAVE_EXPR:
 216       /* In each scan, scan a given save_expr only once.  */
 217       if (value_member (exp, save_exprs))
 218         return list;
 219
 220       save_exprs = tree_cons (NULL_TREE, exp, save_exprs);
 221       return collect_iterators (TREE_OPERAND (exp, 0), list);
 222
 223       /* we do not automatically iterate blocks -- one must */
 224       /* use the FOR construct to do that */
 225
 226     case BLOCK:
 227       return list;
 228
 229     default:
 230       switch (TREE_CODE_CLASS (TREE_CODE (exp)))
 231         {
 232         case '1':
 233           return collect_iterators (TREE_OPERAND (exp, 0), list);
 234
 235         case '2':
 236         case '<':
 237           return collect_iterators (TREE_OPERAND (exp, 0),
 238                                     collect_iterators (TREE_OPERAND (exp, 1),
 239                                                        list));
 240
 241         case 'e':
 242         case 'r':
 243           {
 244             int num_args = tree_code_length[(int) TREE_CODE (exp)];
 245             int i;
 246
 247             /* Some tree codes have RTL, not trees, as operands.  */
 248             switch (TREE_CODE (exp))
 249               {
 250               case CALL_EXPR:
 251                 num_args = 2;
 252                 break;
 253               case METHOD_CALL_EXPR:
 254                 num_args = 3;
 255                 break;
 256               case WITH_CLEANUP_EXPR:
 257                 num_args = 1;
 258                 break;
 259               case RTL_EXPR:
 260                 return list;
 261               default:
 262                 break;
 263               }
 264
 265             for (i = 0; i < num_args; i++)
 266               list = collect_iterators (TREE_OPERAND (exp, i), list);
 267             return list;
 268           }
 269         default:
 270           return list;
 271         }
 272     }
 273 }
 274 \f
 275 /* Emit rtl for the start of a loop for iterator IDECL.
 276
 277    If necessary, create loop counter rtx and store it as DECL_RTL of IDECL.
 278
 279    The prologue normally starts and ends with notes, which are returned
 280    by this function in *START_NOTE and *END_NODE.
 281    If START_NOTE and END_NODE are 0, we don't make those notes.  */
 282
 283 static void
 284 iterator_loop_prologue (idecl, start_note, end_note)
 285      tree idecl;
 286      rtx *start_note, *end_note;
 287 {
 288   tree expr;
 289
 290   /* Force the save_expr in DECL_INITIAL to be calculated
 291      if it hasn't been calculated yet.  */
 292   expand_expr (DECL_INITIAL (idecl), const0_rtx, VOIDmode,
 293                EXPAND_NORMAL);
 294
 295   if (DECL_RTL (idecl) == 0)
 296     expand_decl (idecl);
 297
 298   if (start_note)
 299     *start_note = emit_note (0, NOTE_INSN_DELETED);
 300
 301   /* Initialize counter.  */
 302   expr = build (MODIFY_EXPR, TREE_TYPE (idecl), idecl, integer_zero_node);
 303   TREE_SIDE_EFFECTS (expr) = 1;
 304   expand_expr (expr, const0_rtx, VOIDmode, EXPAND_NORMAL);
 305
 306   expand_start_loop_continue_elsewhere (1);
 307
 308   ITERATOR_BOUND_P (idecl) = 1;
 309
 310   if (end_note)
 311     *end_note = emit_note (0, NOTE_INSN_DELETED);
 312 }
 313
 314 /* Similar to the previous function, but for the end of the loop.
 315
 316    DECL_RTL is zeroed unless we are inside "({...})". The reason for that is
 317    described below.
 318
 319    When we create two (or more) loops based on the same IDECL, and
 320    both inside the same "({...})"  construct, we must be prepared to
 321    delete both of the loops and create a single one on the level
 322    above, i.e.  enclosing the "({...})". The new loop has to use the
 323    same counter rtl because the references to the iterator decl
 324    (IDECL) have already been expanded as references to the counter
 325    rtl.
 326
 327    It is incorrect to use the same counter reg in different functions,
 328    and it is desirable to use different counters in disjoint loops
 329    when we know there's no need to combine them (because then they can
 330    get allocated separately).  */
 331
 332 static void
 333 iterator_loop_epilogue (idecl, start_note, end_note)
 334      tree idecl;
 335      rtx *start_note, *end_note;
 336 {
 337   tree test, incr;
 338
 339   if (start_note)
 340     *start_note = emit_note (0, NOTE_INSN_DELETED);
 341   expand_loop_continue_here ();
 342   incr = build_binary_op (PLUS_EXPR, idecl, integer_one_node, 0);
 343   incr = build (MODIFY_EXPR, TREE_TYPE (idecl), idecl, incr);
 344   TREE_SIDE_EFFECTS (incr) = 1;
 345   expand_expr (incr, const0_rtx, VOIDmode, EXPAND_NORMAL);
 346   test = build_binary_op (LT_EXPR, idecl, DECL_INITIAL (idecl), 0);
 347   expand_exit_loop_if_false (0, test);
 348   expand_end_loop ();
 349
 350   ITERATOR_BOUND_P (idecl) = 0;
 351   /* we can reset rtl since there is not chance that this expansion */
 352   /* would be superseded by a higher level one */
 353   /* but don't do this if the decl is static, since we need to share */
 354   /* the same decl in that case.  */
 355   if (top_level_ixpansion_p () && ! TREE_STATIC (idecl))
 356     DECL_RTL (idecl) = 0;
 357   if (end_note)
 358     *end_note = emit_note (0, NOTE_INSN_DELETED);
 359 }
 360 \f
 361 /* Return true if we are not currently inside a "({...})" construct.  */
 362
 363 static int
 364 top_level_ixpansion_p ()
 365 {
 366   return iter_stack == 0;
 367 }
 368
 369 /* Given two chains of iter_stack_nodes,
 370    append the nodes in X into Y.  */
 371
 372 static void
 373 isn_append (x, y)
 374      struct iter_stack_node *x, *y;
 375 {
 376   if (x->first == 0)
 377     return;
 378
 379   if (y->first == 0)
 380     {
 381       y->first = x->first;
 382       y->last  = x->last;
 383     }
 384   else
 385     {
 386       y->last->next = x->first;
 387       y->last = x->last;
 388     }
 389 }
 390
 391 /** Make X empty **/
 392
 393 #define ISN_ZERO(X) (X).first=(X).last=0
 394 \f
 395 /* Move the ixpansions in sublevel_ixpansions into the current
 396    node on the iter_stack, or discard them if the iter_stack is empty.
 397    We do this at the end of a statement.  */
 398
 399 static void
 400 istack_sublevel_to_current ()
 401 {
 402   /* At the top level we can throw away sublevel's expansions  **/
 403   /* because there is nobody above us to ask for a cleanup **/
 404   if (iter_stack != 0)
 405     /** Merging with empty sublevel list is a no-op **/
 406     if (sublevel_ixpansions.last)
 407       isn_append (&sublevel_ixpansions, iter_stack);
 408
 409   if (iter_stack == 0)
 410     obstack_free (&ixp_obstack, ixp_firstobj);
 411
 412   ISN_ZERO (sublevel_ixpansions);
 413 }
 414
 415 /* Push a new node on the iter_stack, when we enter a ({...}).  */
 416
 417 void
 418 push_iterator_stack ()
 419 {
 420   struct iter_stack_node *new_top
 421     = (struct iter_stack_node *)
 422       obstack_alloc (&ixp_obstack, sizeof (struct iter_stack_node));
 423
 424   new_top->first = 0;
 425   new_top->last = 0;
 426   new_top->next = iter_stack;
 427   iter_stack = new_top;
 428 }
 429
 430 /* Pop iter_stack, moving the ixpansions in the node being popped
 431    into sublevel_ixpansions.  */
 432
 433 void
 434 pop_iterator_stack ()
 435 {
 436   if (iter_stack == 0)
 437     abort ();
 438
 439   isn_append (iter_stack, &sublevel_ixpansions);
 440   /** Pop current level node: */
 441   iter_stack = iter_stack->next;
 442 }
 443 \f
 444
 445 /* Record an iterator expansion ("ixpansion") for IDECL.
 446    The remaining parameters are the notes in the loop entry
 447    and exit rtl.  */
 448
 449 static void
 450 add_ixpansion (idecl, pro_start, pro_end, epi_start, epi_end)
 451      tree idecl;
 452      rtx pro_start, pro_end, epi_start, epi_end;
 453 {
 454   struct ixpansion *newix;
 455
 456   /* Do nothing if we are not inside "({...})",
 457      as in that case this expansion can't need subsequent RTL modification.  */
 458   if (iter_stack == 0)
 459     return;
 460
 461   newix = (struct ixpansion *) obstack_alloc (&ixp_obstack,
 462                                               sizeof (struct ixpansion));
 463   newix->ixdecl = idecl;
 464   newix->ixprologue_start = pro_start;
 465   newix->ixprologue_end   = pro_end;
 466   newix->ixepilogue_start = epi_start;
 467   newix->ixepilogue_end   = epi_end;
 468
 469   newix->next = iter_stack->first;
 470   iter_stack->first = newix;
 471   if (iter_stack->last == 0)
 472     iter_stack->last = newix;
 473 }
 474
 475 /* Delete the RTL for all ixpansions for iterator IDECL
 476    in our sublevels.  We do this when we make a larger
 477    containing expansion for IDECL.  */
 478
 479 static void
 480 delete_ixpansion (idecl)
 481      tree idecl;
 482 {
 483   struct ixpansion *previx = 0, *ix;
 484
 485   for (ix = sublevel_ixpansions.first; ix; ix = ix->next)
 486     if (ix->ixdecl == idecl)
 487       {
 488         /** zero means that this is a mark for FOR -- **/
 489         /** we do not delete anything, just issue an error. **/
 490
 491         if (ix->ixprologue_start == 0)
 492           error_with_decl (idecl,
 493                            "`for (%s)' appears within implicit iteration");
 494         else
 495           {
 496             rtx insn;
 497             /* We delete all insns, including notes because leaving loop */
 498             /* notes and barriers produced by iterator expansion would */
 499             /* be misleading to other phases */
 500
 501             for (insn = NEXT_INSN (ix->ixprologue_start);
 502                  insn != ix->ixprologue_end;
 503                  insn = NEXT_INSN (insn))
 504               delete_insn (insn);
 505             for (insn = NEXT_INSN (ix->ixepilogue_start);
 506                  insn != ix->ixepilogue_end;
 507                  insn = NEXT_INSN (insn))
 508               delete_insn (insn);
 509           }
 510
 511         /* Delete this ixpansion from sublevel_ixpansions.  */
 512         if (previx)
 513           previx->next = ix->next;
 514         else
 515           sublevel_ixpansions.first = ix->next;
 516         if (sublevel_ixpansions.last == ix)
 517           sublevel_ixpansions.last = previx;
 518       }
 519     else
 520       previx = ix;
 521 }
 522 \f
 523 #ifdef DEBUG_ITERATORS
 524
 525 /* The functions below are for use from source level debugger.
 526    They print short forms of iterator lists and the iterator stack.  */
 527
 528 /* Print the name of the iterator D.  */
 529
 530 void
 531 prdecl (d)
 532      tree d;
 533 {
 534   if (d)
 535     {
 536       if (TREE_CODE (d) == VAR_DECL)
 537         {
 538           tree tname = DECL_NAME (d);
 539           char *dname = IDENTIFIER_POINTER (tname);
 540           fprintf (stderr, dname);
 541         }
 542       else
 543         fprintf (stderr, "<<?>>");
 544     }
 545   else
 546     fprintf (stderr, "<<0>>");
 547 }
 548
 549 /* Print Iterator List -- names only */
 550
 551 tree
 552 pil (head)
 553      tree head;
 554 {
 555   tree current, next;
 556   for (current = head; current; current = next)
 557     {
 558       tree node = TREE_VALUE (current);
 559       prdecl (node);
 560       next = TREE_CHAIN (current);
 561       if (next) fprintf (stderr, ",");
 562     }
 563   fprintf (stderr, "\n");
 564 }
 565
 566 /* Print IXpansion List */
 567
 568 struct ixpansion *
 569 pixl (head)
 570      struct ixpansion *head;
 571 {
 572   struct ixpansion *current, *next;
 573   fprintf (stderr, "> ");
 574   if (head == 0)
 575     fprintf (stderr, "(empty)");
 576
 577   for (current=head; current; current = next)
 578     {
 579       tree node = current->ixdecl;
 580       prdecl (node);
 581       next = current->next;
 582       if (next)
 583         fprintf (stderr, ",");
 584     }
 585   fprintf (stderr, "\n");
 586   return head;
 587 }
 588
 589 /* Print Iterator Stack.  */
 590
 591 void
 592 pis ()
 593 {
 594   struct iter_stack_node *stack_node;
 595
 596   fprintf (stderr, "--SubLevel: ");
 597   pixl (sublevel_ixpansions.first);
 598   fprintf (stderr, "--Stack:--\n");
 599   for (stack_node = iter_stack;
 600        stack_node;
 601        stack_node = stack_node->next)
 602     pixl (stack_node->first);
 603 }
 604
 605 #endif /* DEBUG_ITERATORS */