1/* List management for the GCC expander.
2 Copyright (C) 1987-2025 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20#include "config.h"
21#include "system.h"
22#include "coretypes.h"
23#include "tm.h"
24#include "rtl.h"
25
26static void free_list (rtx *, rtx *);
27
28/* Functions for maintaining cache-able lists of EXPR_LIST and INSN_LISTs. */
29
30/* An INSN_LIST containing all INSN_LISTs allocated but currently unused. */
31static GTY ((deletable)) rtx unused_insn_list;
32
33/* An EXPR_LIST containing all EXPR_LISTs allocated but currently unused. */
34static GTY ((deletable)) rtx unused_expr_list;
35
36/* This function will free an entire list of either EXPR_LIST, INSN_LIST
37 or DEPS_LIST nodes. This is to be used only on lists that consist
38 exclusively of nodes of one type only. This is only called by
39 free_EXPR_LIST_list, free_INSN_LIST_list and free_DEPS_LIST_list. */
40static void
41free_list (rtx *listp, rtx *unused_listp)
42{
43 rtx link, prev_link;
44
45 prev_link = *listp;
46 link = XEXP (prev_link, 1);
47
48 gcc_assert (unused_listp != &unused_insn_list
49 || GET_CODE (prev_link) == INSN_LIST);
50
51 while (link)
52 {
53 gcc_assert (unused_listp != &unused_insn_list
54 || GET_CODE (prev_link) == INSN_LIST);
55
56 prev_link = link;
57 link = XEXP (link, 1);
58 }
59
60 XEXP (prev_link, 1) = *unused_listp;
61 *unused_listp = *listp;
62 *listp = 0;
63}
64
65/* Find corresponding to ELEM node in the list pointed to by LISTP.
66 This node must exist in the list. Returns pointer to that node. */
67static rtx *
68find_list_elem (rtx elem, rtx *listp)
69{
70 while (XEXP (*listp, 0) != elem)
71 listp = &XEXP (*listp, 1);
72 return listp;
73}
74
75/* Remove the node pointed to by LISTP from the list. */
76static void
77remove_list_node (rtx *listp)
78{
79 rtx node;
80
81 node = *listp;
82 *listp = XEXP (node, 1);
83 XEXP (node, 1) = 0;
84}
85
86/* Removes corresponding to ELEM node from the list pointed to by LISTP.
87 Returns that node. */
88rtx
89remove_list_elem (rtx elem, rtx *listp)
90{
91 rtx node;
92
93 listp = find_list_elem (elem, listp);
94 node = *listp;
95 remove_list_node (listp);
96 return node;
97}
98
99/* This call is used in place of a gen_rtx_INSN_LIST. If there is a cached
100 node available, we'll use it, otherwise a call to gen_rtx_INSN_LIST
101 is made. */
102rtx_insn_list *
103alloc_INSN_LIST (rtx val, rtx next)
104{
105 rtx_insn_list *r;
106
107 if (unused_insn_list)
108 {
109 r = as_a <rtx_insn_list *> (p: unused_insn_list);
110 unused_insn_list = r->next ();
111 XEXP (r, 0) = val;
112 XEXP (r, 1) = next;
113 PUT_REG_NOTE_KIND (r, VOIDmode);
114
115 gcc_assert (GET_CODE (r) == INSN_LIST);
116 }
117 else
118 r = gen_rtx_INSN_LIST (VOIDmode, val, next);
119
120 return r;
121}
122
123/* This call is used in place of a gen_rtx_EXPR_LIST. If there is a cached
124 node available, we'll use it, otherwise a call to gen_rtx_EXPR_LIST
125 is made. */
126rtx_expr_list *
127alloc_EXPR_LIST (int kind, rtx val, rtx next)
128{
129 rtx_expr_list *r;
130
131 if (unused_expr_list)
132 {
133 r = as_a <rtx_expr_list *> (p: unused_expr_list);
134 unused_expr_list = XEXP (r, 1);
135 XEXP (r, 0) = val;
136 XEXP (r, 1) = next;
137 PUT_REG_NOTE_KIND (r, kind);
138 }
139 else
140 r = gen_rtx_EXPR_LIST ((machine_mode) kind, val, next);
141
142 return r;
143}
144
145/* This function will free up an entire list of EXPR_LIST nodes. */
146void
147free_EXPR_LIST_list (rtx_expr_list **listp)
148{
149 if (*listp == 0)
150 return;
151 free_list (listp: (rtx *)listp, unused_listp: &unused_expr_list);
152}
153
154/* This function will free up an entire list of INSN_LIST nodes. */
155void
156free_INSN_LIST_list (rtx_insn_list **listp)
157{
158 if (*listp == 0)
159 return;
160 free_list (listp: (rtx *)listp, unused_listp: &unused_insn_list);
161}
162
163/* Make a copy of the INSN_LIST list LINK and return it. */
164rtx_insn_list *
165copy_INSN_LIST (rtx_insn_list *link)
166{
167 rtx_insn_list *new_queue;
168 rtx_insn_list **pqueue = &new_queue;
169
170 for (; link; link = link->next ())
171 {
172 rtx_insn *x = link->insn ();
173 rtx_insn_list *newlink = alloc_INSN_LIST (val: x, NULL);
174 *pqueue = newlink;
175 pqueue = (rtx_insn_list **)&XEXP (newlink, 1);
176 }
177 *pqueue = NULL;
178 return new_queue;
179}
180
181/* Duplicate the INSN_LIST elements of COPY and prepend them to OLD. */
182rtx_insn_list *
183concat_INSN_LIST (rtx_insn_list *copy, rtx_insn_list *old)
184{
185 rtx_insn_list *new_rtx = old;
186 for (; copy ; copy = copy->next ())
187 {
188 new_rtx = alloc_INSN_LIST (val: copy->insn (), next: new_rtx);
189 PUT_REG_NOTE_KIND (new_rtx, REG_NOTE_KIND (copy));
190 }
191 return new_rtx;
192}
193
194/* This function will free up an individual EXPR_LIST node. */
195void
196free_EXPR_LIST_node (rtx ptr)
197{
198 XEXP (ptr, 1) = unused_expr_list;
199 unused_expr_list = ptr;
200}
201
202/* This function will free up an individual INSN_LIST node. */
203void
204free_INSN_LIST_node (rtx ptr)
205{
206 gcc_assert (GET_CODE (ptr) == INSN_LIST);
207 XEXP (ptr, 1) = unused_insn_list;
208 unused_insn_list = ptr;
209}
210
211/* Remove and free corresponding to ELEM node in the INSN_LIST pointed to
212 by LISTP. */
213void
214remove_free_INSN_LIST_elem (rtx_insn *elem, rtx_insn_list **listp)
215{
216 free_INSN_LIST_node (ptr: remove_list_elem (elem, listp: (rtx *)listp));
217}
218
219/* Remove and free the first node in the INSN_LIST pointed to by LISTP. */
220rtx_insn *
221remove_free_INSN_LIST_node (rtx_insn_list **listp)
222{
223 rtx_insn_list *node = *listp;
224 rtx_insn *elem = node->insn ();
225
226 remove_list_node (listp: (rtx *)listp);
227 free_INSN_LIST_node (ptr: node);
228
229 return elem;
230}
231
232/* Remove and free the first node in the EXPR_LIST pointed to by LISTP. */
233rtx
234remove_free_EXPR_LIST_node (rtx_expr_list **listp)
235{
236 rtx_expr_list *node = *listp;
237 rtx elem = XEXP (node, 0);
238
239 remove_list_node (listp: (rtx *)listp);
240 free_EXPR_LIST_node (ptr: node);
241
242 return elem;
243}
244
245#include "gt-lists.h"
246

source code of gcc/lists.cc