gcc/lists.c

   1 /* List management for the GCC expander.
   2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
   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 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "toplev.h"
  26 #include "rtl.h"
  27 #include "ggc.h"
  28
  29 static void free_list (rtx *, rtx *);
  30
  31 /* Functions for maintaining cache-able lists of EXPR_LIST and INSN_LISTs.  */
  32
  33 /* An INSN_LIST containing all INSN_LISTs allocated but currently unused.  */
  34 static GTY ((deletable)) rtx unused_insn_list;
  35
  36 /* An EXPR_LIST containing all EXPR_LISTs allocated but currently unused.  */
  37 static GTY ((deletable)) rtx unused_expr_list;
  38
  39 /* This function will free an entire list of either EXPR_LIST, INSN_LIST
  40    or DEPS_LIST nodes.  This is to be used only on lists that consist
  41    exclusively of nodes of one type only.  This is only called by
  42    free_EXPR_LIST_list, free_INSN_LIST_list and free_DEPS_LIST_list.  */
  43 static void
  44 free_list (rtx *listp, rtx *unused_listp)
  45 {
  46   rtx link, prev_link;
  47
  48   prev_link = *listp;
  49   link = XEXP (prev_link, 1);
  50
  51   gcc_assert (unused_listp != &unused_insn_list
  52               || GET_CODE (prev_link) == INSN_LIST);
  53
  54   while (link)
  55     {
  56       gcc_assert (unused_listp != &unused_insn_list
  57                   || GET_CODE (prev_link) == INSN_LIST);
  58
  59       prev_link = link;
  60       link = XEXP (link, 1);
  61     }
  62
  63   XEXP (prev_link, 1) = *unused_listp;
  64   *unused_listp = *listp;
  65   *listp = 0;
  66 }
  67
  68 /* Find corresponding to ELEM node in the list pointed to by LISTP.
  69    This node must exist in the list.  Returns pointer to that node.  */
  70 static rtx *
  71 find_list_elem (rtx elem, rtx *listp)
  72 {
  73   while (XEXP (*listp, 0) != elem)
  74     listp = &XEXP (*listp, 1);
  75   return listp;
  76 }
  77
  78 /* Remove the node pointed to by LISTP from the list.  */
  79 static void
  80 remove_list_node (rtx *listp)
  81 {
  82   rtx node;
  83
  84   node = *listp;
  85   *listp = XEXP (node, 1);
  86   XEXP (node, 1) = 0;
  87 }
  88
  89 /* Removes corresponding to ELEM node from the list pointed to by LISTP.
  90    Returns that node.  */
  91 rtx
  92 remove_list_elem (rtx elem, rtx *listp)
  93 {
  94   rtx node;
  95
  96   listp = find_list_elem (elem, listp);
  97   node = *listp;
  98   remove_list_node (listp);
  99   return node;
 100 }
 101
 102 /* This call is used in place of a gen_rtx_INSN_LIST. If there is a cached
 103    node available, we'll use it, otherwise a call to gen_rtx_INSN_LIST
 104    is made.  */
 105 rtx
 106 alloc_INSN_LIST (rtx val, rtx next)
 107 {
 108   rtx r;
 109
 110   if (unused_insn_list)
 111     {
 112       r = unused_insn_list;
 113       unused_insn_list = XEXP (r, 1);
 114       XEXP (r, 0) = val;
 115       XEXP (r, 1) = next;
 116       PUT_REG_NOTE_KIND (r, VOIDmode);
 117
 118       gcc_assert (GET_CODE (r) == INSN_LIST);
 119     }
 120   else
 121     r = gen_rtx_INSN_LIST (VOIDmode, val, next);
 122
 123   return r;
 124 }
 125
 126 /* This call is used in place of a gen_rtx_EXPR_LIST. If there is a cached
 127    node available, we'll use it, otherwise a call to gen_rtx_EXPR_LIST
 128    is made.  */
 129 rtx
 130 alloc_EXPR_LIST (int kind, rtx val, rtx next)
 131 {
 132   rtx r;
 133
 134   if (unused_expr_list)
 135     {
 136       r = unused_expr_list;
 137       unused_expr_list = XEXP (r, 1);
 138       XEXP (r, 0) = val;
 139       XEXP (r, 1) = next;
 140       PUT_REG_NOTE_KIND (r, kind);
 141     }
 142   else
 143     r = gen_rtx_EXPR_LIST (kind, val, next);
 144
 145   return r;
 146 }
 147
 148 /* This function will free up an entire list of EXPR_LIST nodes.  */
 149 void
 150 free_EXPR_LIST_list (rtx *listp)
 151 {
 152   if (*listp == 0)
 153     return;
 154   free_list (listp, &unused_expr_list);
 155 }
 156
 157 /* This function will free up an entire list of INSN_LIST nodes.  */
 158 void
 159 free_INSN_LIST_list (rtx *listp)
 160 {
 161   if (*listp == 0)
 162     return;
 163   free_list (listp, &unused_insn_list);
 164 }
 165
 166 /* This function will free up an individual EXPR_LIST node.  */
 167 void
 168 free_EXPR_LIST_node (rtx ptr)
 169 {
 170   XEXP (ptr, 1) = unused_expr_list;
 171   unused_expr_list = ptr;
 172 }
 173
 174 /* This function will free up an individual INSN_LIST node.  */
 175 void
 176 free_INSN_LIST_node (rtx ptr)
 177 {
 178   gcc_assert (GET_CODE (ptr) == INSN_LIST);
 179   XEXP (ptr, 1) = unused_insn_list;
 180   unused_insn_list = ptr;
 181 }
 182
 183 /* Remove and free corresponding to ELEM node in the INSN_LIST pointed to
 184    by LISTP.  */
 185 void
 186 remove_free_INSN_LIST_elem (rtx elem, rtx *listp)
 187 {
 188   free_INSN_LIST_node (remove_list_elem (elem, listp));
 189 }
 190
 191 /* Remove and free the first node in the INSN_LIST pointed to by LISTP.  */
 192 rtx
 193 remove_free_INSN_LIST_node (rtx *listp)
 194 {
 195   rtx node = *listp;
 196   rtx elem = XEXP (node, 0);
 197
 198   remove_list_node (listp);
 199   free_INSN_LIST_node (node);
 200
 201   return elem;
 202 }
 203
 204 /* Remove and free the first node in the EXPR_LIST pointed to by LISTP.  */
 205 rtx
 206 remove_free_EXPR_LIST_node (rtx *listp)
 207 {
 208   rtx node = *listp;
 209   rtx elem = XEXP (node, 0);
 210
 211   remove_list_node (listp);
 212   free_EXPR_LIST_node (node);
 213
 214   return elem;
 215 }
 216
 217 #include "gt-lists.h"