annotate gcc/read-rtl.c @ 158:494b0b89df80 default tip

...
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Mon, 25 May 2020 18:13:55 +0900
parents 1830386684a0
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1 /* RTL reader for GCC.
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
2 Copyright (C) 1987-2020 Free Software Foundation, Inc.
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
3
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
4 This file is part of GCC.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
5
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
6 GCC is free software; you can redistribute it and/or modify it under
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
7 the terms of the GNU General Public License as published by the Free
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
8 Software Foundation; either version 3, or (at your option) any later
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
9 version.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
10
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
14 for more details.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
15
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
16 You should have received a copy of the GNU General Public License
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
17 along with GCC; see the file COPYING3. If not see
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
18 <http://www.gnu.org/licenses/>. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
19
111
kono
parents: 67
diff changeset
20 /* This file is compiled twice: once for the generator programs
kono
parents: 67
diff changeset
21 once for the compiler. */
kono
parents: 67
diff changeset
22 #ifdef GENERATOR_FILE
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
23 #include "bconfig.h"
111
kono
parents: 67
diff changeset
24 #else
kono
parents: 67
diff changeset
25 #include "config.h"
kono
parents: 67
diff changeset
26 #endif
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
27
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
28 /* Disable rtl checking; it conflicts with the iterator handling. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
29 #undef ENABLE_RTL_CHECKING
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
30
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
31 #include "system.h"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
32 #include "coretypes.h"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
33 #include "tm.h"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
34 #include "rtl.h"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
35 #include "obstack.h"
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
36 #include "read-md.h"
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
37 #include "gensupport.h"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
38
111
kono
parents: 67
diff changeset
39 #ifndef GENERATOR_FILE
kono
parents: 67
diff changeset
40 #include "function.h"
kono
parents: 67
diff changeset
41 #include "memmodel.h"
kono
parents: 67
diff changeset
42 #include "emit-rtl.h"
kono
parents: 67
diff changeset
43 #endif
kono
parents: 67
diff changeset
44
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
45 /* One element in a singly-linked list of (integer, string) pairs. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
46 struct map_value {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
47 struct map_value *next;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
48 int number;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
49 const char *string;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
50 };
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
51
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
52 /* Maps an iterator or attribute name to a list of (integer, string) pairs.
111
kono
parents: 67
diff changeset
53 The integers are iterator values; the strings are either C conditions
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
54 or attribute values. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
55 struct mapping {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
56 /* The name of the iterator or attribute. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
57 const char *name;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
58
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
59 /* The group (modes or codes) to which the iterator or attribute belongs. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
60 struct iterator_group *group;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
61
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
62 /* The list of (integer, string) pairs. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
63 struct map_value *values;
111
kono
parents: 67
diff changeset
64
kono
parents: 67
diff changeset
65 /* For iterators, records the current value of the iterator. */
kono
parents: 67
diff changeset
66 struct map_value *current_value;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
67 };
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
68
111
kono
parents: 67
diff changeset
69 /* A structure for abstracting the common parts of iterators. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
70 struct iterator_group {
111
kono
parents: 67
diff changeset
71 /* Tables of "mapping" structures, one for attributes and one for
kono
parents: 67
diff changeset
72 iterators. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
73 htab_t attrs, iterators;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
74
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
75 /* The C++ type of the iterator, such as "machine_mode" for modes. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
76 const char *type;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
77
111
kono
parents: 67
diff changeset
78 /* Treat the given string as the name of a standard mode, etc., and
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
79 return its integer value. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
80 int (*find_builtin) (const char *);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
81
111
kono
parents: 67
diff changeset
82 /* Make the given rtx use the iterator value given by the third argument.
kono
parents: 67
diff changeset
83 If the iterator applies to operands, the second argument gives the
kono
parents: 67
diff changeset
84 operand index, otherwise it is ignored. */
kono
parents: 67
diff changeset
85 void (*apply_iterator) (rtx, unsigned int, int);
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
86
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
87 /* Return the C token for the given standard mode, code, etc. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
88 const char *(*get_c_token) (int);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
89 };
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
90
111
kono
parents: 67
diff changeset
91 /* Records one use of an iterator. */
kono
parents: 67
diff changeset
92 struct iterator_use {
kono
parents: 67
diff changeset
93 /* The iterator itself. */
kono
parents: 67
diff changeset
94 struct mapping *iterator;
kono
parents: 67
diff changeset
95
kono
parents: 67
diff changeset
96 /* The location of the use, as passed to the apply_iterator callback.
kono
parents: 67
diff changeset
97 The index is the number of the operand that used the iterator
kono
parents: 67
diff changeset
98 if applicable, otherwise it is ignored. */
kono
parents: 67
diff changeset
99 rtx x;
kono
parents: 67
diff changeset
100 unsigned int index;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
101 };
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
102
111
kono
parents: 67
diff changeset
103 /* Records one use of an attribute (the "<[iterator:]attribute>" syntax)
kono
parents: 67
diff changeset
104 in a non-string rtx field. */
kono
parents: 67
diff changeset
105 struct attribute_use {
kono
parents: 67
diff changeset
106 /* The group that describes the use site. */
kono
parents: 67
diff changeset
107 struct iterator_group *group;
kono
parents: 67
diff changeset
108
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
109 /* The location at which the use occurs. */
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
110 file_location loc;
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
111
111
kono
parents: 67
diff changeset
112 /* The name of the attribute, possibly with an "iterator:" prefix. */
kono
parents: 67
diff changeset
113 const char *value;
kono
parents: 67
diff changeset
114
kono
parents: 67
diff changeset
115 /* The location of the use, as passed to GROUP's apply_iterator callback.
kono
parents: 67
diff changeset
116 The index is the number of the operand that used the iterator
kono
parents: 67
diff changeset
117 if applicable, otherwise it is ignored. */
kono
parents: 67
diff changeset
118 rtx x;
kono
parents: 67
diff changeset
119 unsigned int index;
kono
parents: 67
diff changeset
120 };
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
121
111
kono
parents: 67
diff changeset
122 /* This struct is used to link subst_attr named ATTR_NAME with
kono
parents: 67
diff changeset
123 corresponding define_subst named ITER_NAME. */
kono
parents: 67
diff changeset
124 struct subst_attr_to_iter_mapping
kono
parents: 67
diff changeset
125 {
kono
parents: 67
diff changeset
126 char *attr_name;
kono
parents: 67
diff changeset
127 char *iter_name;
kono
parents: 67
diff changeset
128 };
kono
parents: 67
diff changeset
129
kono
parents: 67
diff changeset
130 /* Hash-table to store links between subst-attributes and
kono
parents: 67
diff changeset
131 define_substs. */
kono
parents: 67
diff changeset
132 htab_t subst_attr_to_iter_map = NULL;
kono
parents: 67
diff changeset
133 /* This global stores name of subst-iterator which is currently being
kono
parents: 67
diff changeset
134 processed. */
kono
parents: 67
diff changeset
135 const char *current_iterator_name;
kono
parents: 67
diff changeset
136
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
137 static void validate_const_int (const char *);
111
kono
parents: 67
diff changeset
138 static void one_time_initialization (void);
kono
parents: 67
diff changeset
139
kono
parents: 67
diff changeset
140 /* Global singleton. */
kono
parents: 67
diff changeset
141 rtx_reader *rtx_reader_ptr = NULL;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
142
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
143 /* The mode and code iterator structures. */
111
kono
parents: 67
diff changeset
144 static struct iterator_group modes, codes, ints, substs;
kono
parents: 67
diff changeset
145
kono
parents: 67
diff changeset
146 /* All iterators used in the current rtx. */
kono
parents: 67
diff changeset
147 static vec<mapping *> current_iterators;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
148
111
kono
parents: 67
diff changeset
149 /* The list of all iterator uses in the current rtx. */
kono
parents: 67
diff changeset
150 static vec<iterator_use> iterator_uses;
kono
parents: 67
diff changeset
151
kono
parents: 67
diff changeset
152 /* The list of all attribute uses in the current rtx. */
kono
parents: 67
diff changeset
153 static vec<attribute_use> attribute_uses;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
154
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
155 /* Implementations of the iterator_group callbacks for modes. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
156
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
157 static int
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
158 find_mode (const char *name)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
159 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
160 int i;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
161
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
162 for (i = 0; i < NUM_MACHINE_MODES; i++)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
163 if (strcmp (GET_MODE_NAME (i), name) == 0)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
164 return i;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
165
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
166 fatal_with_file_and_line ("unknown mode `%s'", name);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
167 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
168
111
kono
parents: 67
diff changeset
169 static void
kono
parents: 67
diff changeset
170 apply_mode_iterator (rtx x, unsigned int, int mode)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
171 {
111
kono
parents: 67
diff changeset
172 PUT_MODE (x, (machine_mode) mode);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
173 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
174
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
175 static const char *
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
176 get_mode_token (int mode)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
177 {
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
178 return concat ("E_", GET_MODE_NAME (mode), "mode", NULL);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
179 }
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
180
111
kono
parents: 67
diff changeset
181 /* In compact dumps, the code of insns is prefixed with "c", giving "cinsn",
kono
parents: 67
diff changeset
182 "cnote" etc, and CODE_LABEL is special-cased as "clabel". */
kono
parents: 67
diff changeset
183
kono
parents: 67
diff changeset
184 struct compact_insn_name {
kono
parents: 67
diff changeset
185 RTX_CODE code;
kono
parents: 67
diff changeset
186 const char *name;
kono
parents: 67
diff changeset
187 };
kono
parents: 67
diff changeset
188
kono
parents: 67
diff changeset
189 static const compact_insn_name compact_insn_names[] = {
kono
parents: 67
diff changeset
190 { DEBUG_INSN, "cdebug_insn" },
kono
parents: 67
diff changeset
191 { INSN, "cinsn" },
kono
parents: 67
diff changeset
192 { JUMP_INSN, "cjump_insn" },
kono
parents: 67
diff changeset
193 { CALL_INSN, "ccall_insn" },
kono
parents: 67
diff changeset
194 { JUMP_TABLE_DATA, "cjump_table_data" },
kono
parents: 67
diff changeset
195 { BARRIER, "cbarrier" },
kono
parents: 67
diff changeset
196 { CODE_LABEL, "clabel" },
kono
parents: 67
diff changeset
197 { NOTE, "cnote" }
kono
parents: 67
diff changeset
198 };
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
199
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
200 /* Return the rtx code for NAME, or UNKNOWN if NAME isn't a valid rtx code. */
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
201
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
202 static rtx_code
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
203 maybe_find_code (const char *name)
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
204 {
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
205 for (int i = 0; i < NUM_RTX_CODE; i++)
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
206 if (strcmp (GET_RTX_NAME (i), name) == 0)
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
207 return (rtx_code) i;
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
208
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
209 for (int i = 0; i < (signed)ARRAY_SIZE (compact_insn_names); i++)
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
210 if (strcmp (compact_insn_names[i].name, name) == 0)
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
211 return compact_insn_names[i].code;
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
212
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
213 return UNKNOWN;
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
214 }
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
215
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
216 /* Implementations of the iterator_group callbacks for codes. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
217
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
218 static int
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
219 find_code (const char *name)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
220 {
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
221 rtx_code code = maybe_find_code (name);
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
222 if (code == UNKNOWN)
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
223 fatal_with_file_and_line ("unknown rtx code `%s'", name);
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
224 return code;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
225 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
226
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
227 static void
111
kono
parents: 67
diff changeset
228 apply_code_iterator (rtx x, unsigned int, int code)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
229 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
230 PUT_CODE (x, (enum rtx_code) code);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
231 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
232
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
233 static const char *
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
234 get_code_token (int code)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
235 {
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
236 char *name = xstrdup (GET_RTX_NAME (code));
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
237 for (int i = 0; name[i]; ++i)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
238 name[i] = TOUPPER (name[i]);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
239 return name;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
240 }
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
241
111
kono
parents: 67
diff changeset
242 /* Implementations of the iterator_group callbacks for ints. */
kono
parents: 67
diff changeset
243
kono
parents: 67
diff changeset
244 /* Since GCC does not construct a table of valid constants,
kono
parents: 67
diff changeset
245 we have to accept any int as valid. No cross-checking can
kono
parents: 67
diff changeset
246 be done. */
kono
parents: 67
diff changeset
247
kono
parents: 67
diff changeset
248 static int
kono
parents: 67
diff changeset
249 find_int (const char *name)
kono
parents: 67
diff changeset
250 {
kono
parents: 67
diff changeset
251 validate_const_int (name);
kono
parents: 67
diff changeset
252 return atoi (name);
kono
parents: 67
diff changeset
253 }
kono
parents: 67
diff changeset
254
kono
parents: 67
diff changeset
255 static void
kono
parents: 67
diff changeset
256 apply_int_iterator (rtx x, unsigned int index, int value)
kono
parents: 67
diff changeset
257 {
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
258 if (GET_CODE (x) == SUBREG)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
259 SUBREG_BYTE (x) = value;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
260 else
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
261 XINT (x, index) = value;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
262 }
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
263
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
264 static const char *
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
265 get_int_token (int value)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
266 {
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
267 char buffer[HOST_BITS_PER_INT + 1];
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
268 sprintf (buffer, "%d", value);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
269 return xstrdup (buffer);
111
kono
parents: 67
diff changeset
270 }
kono
parents: 67
diff changeset
271
kono
parents: 67
diff changeset
272 #ifdef GENERATOR_FILE
kono
parents: 67
diff changeset
273
kono
parents: 67
diff changeset
274 /* This routine adds attribute or does nothing depending on VALUE. When
kono
parents: 67
diff changeset
275 VALUE is 1, it does nothing - the first duplicate of original
kono
parents: 67
diff changeset
276 template is kept untouched when it's subjected to a define_subst.
kono
parents: 67
diff changeset
277 When VALUE isn't 1, the routine modifies RTL-template RT, adding
kono
parents: 67
diff changeset
278 attribute, named exactly as define_subst, which later will be
kono
parents: 67
diff changeset
279 applied. If such attribute has already been added, then no the
kono
parents: 67
diff changeset
280 routine has no effect. */
kono
parents: 67
diff changeset
281 static void
kono
parents: 67
diff changeset
282 apply_subst_iterator (rtx rt, unsigned int, int value)
kono
parents: 67
diff changeset
283 {
kono
parents: 67
diff changeset
284 rtx new_attr;
kono
parents: 67
diff changeset
285 rtvec attrs_vec, new_attrs_vec;
kono
parents: 67
diff changeset
286 int i;
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
287 /* define_split has no attributes. */
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
288 if (value == 1 || GET_CODE (rt) == DEFINE_SPLIT)
111
kono
parents: 67
diff changeset
289 return;
kono
parents: 67
diff changeset
290 gcc_assert (GET_CODE (rt) == DEFINE_INSN
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
291 || GET_CODE (rt) == DEFINE_INSN_AND_SPLIT
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
292 || GET_CODE (rt) == DEFINE_INSN_AND_REWRITE
111
kono
parents: 67
diff changeset
293 || GET_CODE (rt) == DEFINE_EXPAND);
kono
parents: 67
diff changeset
294
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
295 int attrs = (GET_CODE (rt) == DEFINE_INSN_AND_SPLIT ? 7
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
296 : GET_CODE (rt) == DEFINE_INSN_AND_REWRITE ? 6 : 4);
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
297 attrs_vec = XVEC (rt, attrs);
111
kono
parents: 67
diff changeset
298
kono
parents: 67
diff changeset
299 /* If we've already added attribute 'current_iterator_name', then we
kono
parents: 67
diff changeset
300 have nothing to do now. */
kono
parents: 67
diff changeset
301 if (attrs_vec)
kono
parents: 67
diff changeset
302 {
kono
parents: 67
diff changeset
303 for (i = 0; i < GET_NUM_ELEM (attrs_vec); i++)
kono
parents: 67
diff changeset
304 {
kono
parents: 67
diff changeset
305 if (strcmp (XSTR (attrs_vec->elem[i], 0), current_iterator_name) == 0)
kono
parents: 67
diff changeset
306 return;
kono
parents: 67
diff changeset
307 }
kono
parents: 67
diff changeset
308 }
kono
parents: 67
diff changeset
309
kono
parents: 67
diff changeset
310 /* Add attribute with subst name - it serves as a mark for
kono
parents: 67
diff changeset
311 define_subst which later would be applied to this pattern. */
kono
parents: 67
diff changeset
312 new_attr = rtx_alloc (SET_ATTR);
kono
parents: 67
diff changeset
313 PUT_CODE (new_attr, SET_ATTR);
kono
parents: 67
diff changeset
314 XSTR (new_attr, 0) = xstrdup (current_iterator_name);
kono
parents: 67
diff changeset
315 XSTR (new_attr, 1) = xstrdup ("yes");
kono
parents: 67
diff changeset
316
kono
parents: 67
diff changeset
317 if (!attrs_vec)
kono
parents: 67
diff changeset
318 {
kono
parents: 67
diff changeset
319 new_attrs_vec = rtvec_alloc (1);
kono
parents: 67
diff changeset
320 new_attrs_vec->elem[0] = new_attr;
kono
parents: 67
diff changeset
321 }
kono
parents: 67
diff changeset
322 else
kono
parents: 67
diff changeset
323 {
kono
parents: 67
diff changeset
324 new_attrs_vec = rtvec_alloc (GET_NUM_ELEM (attrs_vec) + 1);
kono
parents: 67
diff changeset
325 memcpy (&new_attrs_vec->elem[0], &attrs_vec->elem[0],
kono
parents: 67
diff changeset
326 GET_NUM_ELEM (attrs_vec) * sizeof (rtx));
kono
parents: 67
diff changeset
327 new_attrs_vec->elem[GET_NUM_ELEM (attrs_vec)] = new_attr;
kono
parents: 67
diff changeset
328 }
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
329 XVEC (rt, attrs) = new_attrs_vec;
111
kono
parents: 67
diff changeset
330 }
kono
parents: 67
diff changeset
331
kono
parents: 67
diff changeset
332 /* Map subst-attribute ATTR to subst iterator ITER. */
kono
parents: 67
diff changeset
333
kono
parents: 67
diff changeset
334 static void
kono
parents: 67
diff changeset
335 bind_subst_iter_and_attr (const char *iter, const char *attr)
kono
parents: 67
diff changeset
336 {
kono
parents: 67
diff changeset
337 struct subst_attr_to_iter_mapping *value;
kono
parents: 67
diff changeset
338 void **slot;
kono
parents: 67
diff changeset
339 if (!subst_attr_to_iter_map)
kono
parents: 67
diff changeset
340 subst_attr_to_iter_map =
kono
parents: 67
diff changeset
341 htab_create (1, leading_string_hash, leading_string_eq_p, 0);
kono
parents: 67
diff changeset
342 value = XNEW (struct subst_attr_to_iter_mapping);
kono
parents: 67
diff changeset
343 value->attr_name = xstrdup (attr);
kono
parents: 67
diff changeset
344 value->iter_name = xstrdup (iter);
kono
parents: 67
diff changeset
345 slot = htab_find_slot (subst_attr_to_iter_map, value, INSERT);
kono
parents: 67
diff changeset
346 *slot = value;
kono
parents: 67
diff changeset
347 }
kono
parents: 67
diff changeset
348
kono
parents: 67
diff changeset
349 #endif /* #ifdef GENERATOR_FILE */
kono
parents: 67
diff changeset
350
kono
parents: 67
diff changeset
351 /* Return name of a subst-iterator, corresponding to subst-attribute ATTR. */
kono
parents: 67
diff changeset
352
kono
parents: 67
diff changeset
353 static char*
kono
parents: 67
diff changeset
354 find_subst_iter_by_attr (const char *attr)
kono
parents: 67
diff changeset
355 {
kono
parents: 67
diff changeset
356 char *iter_name = NULL;
kono
parents: 67
diff changeset
357 struct subst_attr_to_iter_mapping *value;
kono
parents: 67
diff changeset
358 value = (struct subst_attr_to_iter_mapping*)
kono
parents: 67
diff changeset
359 htab_find (subst_attr_to_iter_map, &attr);
kono
parents: 67
diff changeset
360 if (value)
kono
parents: 67
diff changeset
361 iter_name = value->iter_name;
kono
parents: 67
diff changeset
362 return iter_name;
kono
parents: 67
diff changeset
363 }
kono
parents: 67
diff changeset
364
kono
parents: 67
diff changeset
365 /* Map attribute string P to its current value. Return null if the attribute
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
366 isn't known. If ITERATOR_OUT is nonnull, store the associated iterator
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
367 there. Report any errors against location LOC. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
368
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
369 static struct map_value *
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
370 map_attr_string (file_location loc, const char *p, mapping **iterator_out = 0)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
371 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
372 const char *attr;
111
kono
parents: 67
diff changeset
373 struct mapping *iterator;
kono
parents: 67
diff changeset
374 unsigned int i;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
375 struct mapping *m;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
376 struct map_value *v;
111
kono
parents: 67
diff changeset
377 int iterator_name_len;
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
378 struct map_value *res = NULL;
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
379 struct mapping *prev = NULL;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
380
111
kono
parents: 67
diff changeset
381 /* Peel off any "iterator:" prefix. Set ATTR to the start of the
kono
parents: 67
diff changeset
382 attribute name. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
383 attr = strchr (p, ':');
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
384 if (attr == 0)
111
kono
parents: 67
diff changeset
385 {
kono
parents: 67
diff changeset
386 iterator_name_len = -1;
kono
parents: 67
diff changeset
387 attr = p;
kono
parents: 67
diff changeset
388 }
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
389 else
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
390 {
111
kono
parents: 67
diff changeset
391 iterator_name_len = attr - p;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
392 attr++;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
393 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
394
111
kono
parents: 67
diff changeset
395 FOR_EACH_VEC_ELT (current_iterators, i, iterator)
kono
parents: 67
diff changeset
396 {
kono
parents: 67
diff changeset
397 /* If an iterator name was specified, check that it matches. */
kono
parents: 67
diff changeset
398 if (iterator_name_len >= 0
kono
parents: 67
diff changeset
399 && (strncmp (p, iterator->name, iterator_name_len) != 0
kono
parents: 67
diff changeset
400 || iterator->name[iterator_name_len] != 0))
kono
parents: 67
diff changeset
401 continue;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
402
111
kono
parents: 67
diff changeset
403 /* Find the attribute specification. */
kono
parents: 67
diff changeset
404 m = (struct mapping *) htab_find (iterator->group->attrs, &attr);
kono
parents: 67
diff changeset
405 if (m)
kono
parents: 67
diff changeset
406 {
kono
parents: 67
diff changeset
407 /* In contrast to code/mode/int iterators, attributes of subst
kono
parents: 67
diff changeset
408 iterators are linked to one specific subst-iterator. So, if
kono
parents: 67
diff changeset
409 we are dealing with subst-iterator, we should check if it's
kono
parents: 67
diff changeset
410 the one which linked with the given attribute. */
kono
parents: 67
diff changeset
411 if (iterator->group == &substs)
kono
parents: 67
diff changeset
412 {
kono
parents: 67
diff changeset
413 char *iter_name = find_subst_iter_by_attr (attr);
kono
parents: 67
diff changeset
414 if (strcmp (iter_name, iterator->name) != 0)
kono
parents: 67
diff changeset
415 continue;
kono
parents: 67
diff changeset
416 }
kono
parents: 67
diff changeset
417 /* Find the attribute value associated with the current
kono
parents: 67
diff changeset
418 iterator value. */
kono
parents: 67
diff changeset
419 for (v = m->values; v; v = v->next)
kono
parents: 67
diff changeset
420 if (v->number == iterator->current_value->number)
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
421 {
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
422 if (res && strcmp (v->string, res->string) != 0)
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
423 {
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
424 error_at (loc, "ambiguous attribute '%s'; could be"
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
425 " '%s' (via '%s:%s') or '%s' (via '%s:%s')",
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
426 attr, res->string, prev->name, attr,
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
427 v->string, iterator->name, attr);
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
428 return v;
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
429 }
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
430 if (iterator_out)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
431 *iterator_out = iterator;
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
432 prev = iterator;
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
433 res = v;
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
434 }
111
kono
parents: 67
diff changeset
435 }
kono
parents: 67
diff changeset
436 }
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
437 return res;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
438 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
439
111
kono
parents: 67
diff changeset
440 /* Apply the current iterator values to STRING. Return the new string
kono
parents: 67
diff changeset
441 if any changes were needed, otherwise return STRING itself. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
442
111
kono
parents: 67
diff changeset
443 const char *
kono
parents: 67
diff changeset
444 md_reader::apply_iterator_to_string (const char *string)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
445 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
446 char *base, *copy, *p, *start, *end;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
447 struct map_value *v;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
448
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
449 if (string == 0 || string[0] == 0)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
450 return string;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
451
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
452 file_location loc = get_md_ptr_loc (string)->loc;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
453 base = p = copy = ASTRDUP (string);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
454 while ((start = strchr (p, '<')) && (end = strchr (start, '>')))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
455 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
456 p = start + 1;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
457
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
458 *end = 0;
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
459 v = map_attr_string (loc, p);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
460 *end = '>';
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
461 if (v == 0)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
462 continue;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
463
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
464 /* Add everything between the last copied byte and the '<',
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
465 then add in the attribute value. */
111
kono
parents: 67
diff changeset
466 obstack_grow (&m_string_obstack, base, start - base);
kono
parents: 67
diff changeset
467 obstack_grow (&m_string_obstack, v->string, strlen (v->string));
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
468 base = end + 1;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
469 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
470 if (base != copy)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
471 {
111
kono
parents: 67
diff changeset
472 obstack_grow (&m_string_obstack, base, strlen (base) + 1);
kono
parents: 67
diff changeset
473 copy = XOBFINISH (&m_string_obstack, char *);
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
474 copy_md_ptr_loc (copy, string);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
475 return copy;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
476 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
477 return string;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
478 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
479
111
kono
parents: 67
diff changeset
480 /* Return a deep copy of X, substituting the current iterator
kono
parents: 67
diff changeset
481 values into any strings. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
482
111
kono
parents: 67
diff changeset
483 rtx
kono
parents: 67
diff changeset
484 md_reader::copy_rtx_for_iterators (rtx original)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
485 {
111
kono
parents: 67
diff changeset
486 const char *format_ptr, *p;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
487 int i, j;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
488 rtx x;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
489
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
490 if (original == 0)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
491 return original;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
492
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
493 /* Create a shallow copy of ORIGINAL. */
111
kono
parents: 67
diff changeset
494 x = rtx_alloc (GET_CODE (original));
kono
parents: 67
diff changeset
495 memcpy (x, original, RTX_CODE_SIZE (GET_CODE (original)));
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
496
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
497 /* Change each string and recursively change each rtx. */
111
kono
parents: 67
diff changeset
498 format_ptr = GET_RTX_FORMAT (GET_CODE (original));
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
499 for (i = 0; format_ptr[i] != 0; i++)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
500 switch (format_ptr[i])
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
501 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
502 case 'T':
111
kono
parents: 67
diff changeset
503 while (XTMPL (x, i) != (p = apply_iterator_to_string (XTMPL (x, i))))
kono
parents: 67
diff changeset
504 XTMPL (x, i) = p;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
505 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
506
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
507 case 'S':
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
508 case 's':
111
kono
parents: 67
diff changeset
509 while (XSTR (x, i) != (p = apply_iterator_to_string (XSTR (x, i))))
kono
parents: 67
diff changeset
510 XSTR (x, i) = p;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
511 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
512
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
513 case 'e':
111
kono
parents: 67
diff changeset
514 XEXP (x, i) = copy_rtx_for_iterators (XEXP (x, i));
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
515 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
516
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
517 case 'V':
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
518 case 'E':
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
519 if (XVEC (original, i))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
520 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
521 XVEC (x, i) = rtvec_alloc (XVECLEN (original, i));
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
522 for (j = 0; j < XVECLEN (x, i); j++)
111
kono
parents: 67
diff changeset
523 XVECEXP (x, i, j)
kono
parents: 67
diff changeset
524 = copy_rtx_for_iterators (XVECEXP (original, i, j));
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
525 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
526 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
527
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
528 default:
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
529 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
530 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
531 return x;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
532 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
533
111
kono
parents: 67
diff changeset
534 #ifdef GENERATOR_FILE
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
535
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
536 /* Return a condition that must satisfy both ORIGINAL and EXTRA. If ORIGINAL
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
537 has the form "&& ..." (as used in define_insn_and_splits), assume that
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
538 EXTRA is already satisfied. Empty strings are treated like "true". */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
539
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
540 static const char *
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
541 add_condition_to_string (const char *original, const char *extra)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
542 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
543 if (original != 0 && original[0] == '&' && original[1] == '&')
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
544 return original;
111
kono
parents: 67
diff changeset
545 return rtx_reader_ptr->join_c_conditions (original, extra);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
546 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
547
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
548 /* Like add_condition, but applied to all conditions in rtx X. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
549
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
550 static void
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
551 add_condition_to_rtx (rtx x, const char *extra)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
552 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
553 switch (GET_CODE (x))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
554 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
555 case DEFINE_INSN:
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
556 case DEFINE_EXPAND:
111
kono
parents: 67
diff changeset
557 case DEFINE_SUBST:
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
558 XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
559 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
560
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
561 case DEFINE_SPLIT:
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
562 case DEFINE_PEEPHOLE:
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
563 case DEFINE_PEEPHOLE2:
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
564 case DEFINE_COND_EXEC:
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
565 XSTR (x, 1) = add_condition_to_string (XSTR (x, 1), extra);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
566 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
567
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
568 case DEFINE_INSN_AND_SPLIT:
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
569 case DEFINE_INSN_AND_REWRITE:
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
570 XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
571 XSTR (x, 4) = add_condition_to_string (XSTR (x, 4), extra);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
572 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
573
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
574 default:
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
575 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
576 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
577 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
578
111
kono
parents: 67
diff changeset
579 /* Apply the current iterator values to all attribute_uses. */
kono
parents: 67
diff changeset
580
kono
parents: 67
diff changeset
581 static void
kono
parents: 67
diff changeset
582 apply_attribute_uses (void)
kono
parents: 67
diff changeset
583 {
kono
parents: 67
diff changeset
584 struct map_value *v;
kono
parents: 67
diff changeset
585 attribute_use *ause;
kono
parents: 67
diff changeset
586 unsigned int i;
kono
parents: 67
diff changeset
587
kono
parents: 67
diff changeset
588 FOR_EACH_VEC_ELT (attribute_uses, i, ause)
kono
parents: 67
diff changeset
589 {
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
590 v = map_attr_string (ause->loc, ause->value);
111
kono
parents: 67
diff changeset
591 if (!v)
kono
parents: 67
diff changeset
592 fatal_with_file_and_line ("unknown iterator value `%s'", ause->value);
kono
parents: 67
diff changeset
593 ause->group->apply_iterator (ause->x, ause->index,
kono
parents: 67
diff changeset
594 ause->group->find_builtin (v->string));
kono
parents: 67
diff changeset
595 }
kono
parents: 67
diff changeset
596 }
kono
parents: 67
diff changeset
597
kono
parents: 67
diff changeset
598 /* A htab_traverse callback for iterators. Add all used iterators
kono
parents: 67
diff changeset
599 to current_iterators. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
600
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
601 static int
111
kono
parents: 67
diff changeset
602 add_current_iterators (void **slot, void *data ATTRIBUTE_UNUSED)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
603 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
604 struct mapping *iterator;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
605
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
606 iterator = (struct mapping *) *slot;
111
kono
parents: 67
diff changeset
607 if (iterator->current_value)
kono
parents: 67
diff changeset
608 current_iterators.safe_push (iterator);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
609 return 1;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
610 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
611
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
612 /* Return a hash value for overloaded_name UNCAST_ONAME. There shouldn't
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
613 be many instances of two overloaded_names having the same name but
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
614 different arguments, so hashing on the name should be good enough in
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
615 practice. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
616
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
617 static hashval_t
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
618 overloaded_name_hash (const void *uncast_oname)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
619 {
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
620 const overloaded_name *oname = (const overloaded_name *) uncast_oname;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
621 return htab_hash_string (oname->name);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
622 }
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
623
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
624 /* Return true if two overloaded_names are similar enough to share
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
625 the same generated functions. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
626
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
627 static int
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
628 overloaded_name_eq_p (const void *uncast_oname1, const void *uncast_oname2)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
629 {
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
630 const overloaded_name *oname1 = (const overloaded_name *) uncast_oname1;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
631 const overloaded_name *oname2 = (const overloaded_name *) uncast_oname2;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
632 if (strcmp (oname1->name, oname2->name) != 0
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
633 || oname1->arg_types.length () != oname2->arg_types.length ())
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
634 return 0;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
635
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
636 for (unsigned int i = 0; i < oname1->arg_types.length (); ++i)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
637 if (strcmp (oname1->arg_types[i], oname2->arg_types[i]) != 0)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
638 return 0;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
639
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
640 return 1;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
641 }
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
642
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
643 /* Return true if X has an instruction name in XSTR (X, 0). */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
644
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
645 static bool
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
646 named_rtx_p (rtx x)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
647 {
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
648 switch (GET_CODE (x))
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
649 {
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
650 case DEFINE_EXPAND:
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
651 case DEFINE_INSN:
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
652 case DEFINE_INSN_AND_SPLIT:
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
653 case DEFINE_INSN_AND_REWRITE:
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
654 return true;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
655
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
656 default:
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
657 return false;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
658 }
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
659 }
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
660
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
661 /* Check whether ORIGINAL is a named pattern whose name starts with '@'.
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
662 If so, return the associated overloaded_name and add the iterator for
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
663 each argument to ITERATORS. Return null otherwise. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
664
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
665 overloaded_name *
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
666 md_reader::handle_overloaded_name (rtx original, vec<mapping *> *iterators)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
667 {
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
668 /* Check for the leading '@'. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
669 if (!named_rtx_p (original) || XSTR (original, 0)[0] != '@')
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
670 return NULL;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
671
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
672 /* Remove the '@', so that no other code needs to worry about it. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
673 const char *name = XSTR (original, 0);
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
674 file_location loc = get_md_ptr_loc (name)->loc;
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
675 copy_md_ptr_loc (name + 1, name);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
676 name += 1;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
677 XSTR (original, 0) = name;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
678
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
679 /* Build a copy of the name without the '<...>' attribute strings.
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
680 Add the iterator associated with each such attribute string to ITERATORS
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
681 and add an associated argument to TMP_ONAME. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
682 char *copy = ASTRDUP (name);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
683 char *base = copy, *start, *end;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
684 overloaded_name tmp_oname;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
685 tmp_oname.arg_types.create (current_iterators.length ());
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
686 bool pending_underscore_p = false;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
687 while ((start = strchr (base, '<')) && (end = strchr (start, '>')))
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
688 {
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
689 *end = 0;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
690 mapping *iterator;
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
691 if (!map_attr_string (loc, start + 1, &iterator))
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
692 fatal_with_file_and_line ("unknown iterator `%s'", start + 1);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
693 *end = '>';
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
694
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
695 /* Remove a trailing underscore, so that we don't end a name
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
696 with "_" or turn "_<...>_" into "__". */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
697 if (start != base && start[-1] == '_')
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
698 {
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
699 start -= 1;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
700 pending_underscore_p = true;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
701 }
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
702
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
703 /* Add the text between either the last '>' or the start of
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
704 the string and this '<'. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
705 obstack_grow (&m_string_obstack, base, start - base);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
706 base = end + 1;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
707
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
708 /* If there's a character we need to keep after the '>', check
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
709 whether we should prefix it with a previously-dropped '_'. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
710 if (base[0] != 0 && base[0] != '<')
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
711 {
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
712 if (pending_underscore_p && base[0] != '_')
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
713 obstack_1grow (&m_string_obstack, '_');
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
714 pending_underscore_p = false;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
715 }
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
716
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
717 /* Record an argument for ITERATOR. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
718 iterators->safe_push (iterator);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
719 tmp_oname.arg_types.safe_push (iterator->group->type);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
720 }
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
721 if (base == copy)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
722 fatal_with_file_and_line ("no iterator attributes in name `%s'", name);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
723
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
724 size_t length = obstack_object_size (&m_string_obstack);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
725 if (length == 0)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
726 fatal_with_file_and_line ("`%s' only contains iterator attributes", name);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
727
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
728 /* Get the completed name. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
729 obstack_grow (&m_string_obstack, base, strlen (base) + 1);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
730 char *new_name = XOBFINISH (&m_string_obstack, char *);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
731 tmp_oname.name = new_name;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
732
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
733 if (!m_overloads_htab)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
734 m_overloads_htab = htab_create (31, overloaded_name_hash,
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
735 overloaded_name_eq_p, NULL);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
736
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
737 /* See whether another pattern had the same overload name and list
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
738 of argument types. Create a new permanent one if not. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
739 void **slot = htab_find_slot (m_overloads_htab, &tmp_oname, INSERT);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
740 overloaded_name *oname = (overloaded_name *) *slot;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
741 if (!oname)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
742 {
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
743 *slot = oname = new overloaded_name;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
744 oname->name = tmp_oname.name;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
745 oname->arg_types = tmp_oname.arg_types;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
746 oname->next = NULL;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
747 oname->first_instance = NULL;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
748 oname->next_instance_ptr = &oname->first_instance;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
749
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
750 *m_next_overload_ptr = oname;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
751 m_next_overload_ptr = &oname->next;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
752 }
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
753 else
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
754 {
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
755 obstack_free (&m_string_obstack, new_name);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
756 tmp_oname.arg_types.release ();
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
757 }
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
758
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
759 return oname;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
760 }
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
761
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
762 /* Add an instance of ONAME for instruction pattern X. ITERATORS[I]
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
763 gives the iterator associated with argument I of ONAME. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
764
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
765 static void
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
766 add_overload_instance (overloaded_name *oname, vec<mapping *> iterators, rtx x)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
767 {
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
768 /* Create the instance. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
769 overloaded_instance *instance = new overloaded_instance;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
770 instance->next = NULL;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
771 instance->arg_values.create (oname->arg_types.length ());
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
772 for (unsigned int i = 0; i < iterators.length (); ++i)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
773 {
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
774 int value = iterators[i]->current_value->number;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
775 const char *name = iterators[i]->group->get_c_token (value);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
776 instance->arg_values.quick_push (name);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
777 }
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
778 instance->name = XSTR (x, 0);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
779 instance->insn = x;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
780
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
781 /* Chain it onto the end of ONAME's list. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
782 *oname->next_instance_ptr = instance;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
783 oname->next_instance_ptr = &instance->next;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
784 }
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
785
111
kono
parents: 67
diff changeset
786 /* Expand all iterators in the current rtx, which is given as ORIGINAL.
kono
parents: 67
diff changeset
787 Build a list of expanded rtxes in the EXPR_LIST pointed to by QUEUE. */
kono
parents: 67
diff changeset
788
kono
parents: 67
diff changeset
789 static void
kono
parents: 67
diff changeset
790 apply_iterators (rtx original, vec<rtx> *queue)
kono
parents: 67
diff changeset
791 {
kono
parents: 67
diff changeset
792 unsigned int i;
kono
parents: 67
diff changeset
793 const char *condition;
kono
parents: 67
diff changeset
794 iterator_use *iuse;
kono
parents: 67
diff changeset
795 struct mapping *iterator;
kono
parents: 67
diff changeset
796 struct map_value *v;
kono
parents: 67
diff changeset
797 rtx x;
kono
parents: 67
diff changeset
798
kono
parents: 67
diff changeset
799 if (iterator_uses.is_empty ())
kono
parents: 67
diff changeset
800 {
kono
parents: 67
diff changeset
801 /* Raise an error if any attributes were used. */
kono
parents: 67
diff changeset
802 apply_attribute_uses ();
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
803
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
804 if (named_rtx_p (original) && XSTR (original, 0)[0] == '@')
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
805 fatal_with_file_and_line ("'@' used without iterators");
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
806
111
kono
parents: 67
diff changeset
807 queue->safe_push (original);
kono
parents: 67
diff changeset
808 return;
kono
parents: 67
diff changeset
809 }
kono
parents: 67
diff changeset
810
kono
parents: 67
diff changeset
811 /* Clear out the iterators from the previous run. */
kono
parents: 67
diff changeset
812 FOR_EACH_VEC_ELT (current_iterators, i, iterator)
kono
parents: 67
diff changeset
813 iterator->current_value = NULL;
kono
parents: 67
diff changeset
814 current_iterators.truncate (0);
kono
parents: 67
diff changeset
815
kono
parents: 67
diff changeset
816 /* Mark the iterators that we need this time. */
kono
parents: 67
diff changeset
817 FOR_EACH_VEC_ELT (iterator_uses, i, iuse)
kono
parents: 67
diff changeset
818 iuse->iterator->current_value = iuse->iterator->values;
kono
parents: 67
diff changeset
819
kono
parents: 67
diff changeset
820 /* Get the list of iterators that are in use, preserving the
kono
parents: 67
diff changeset
821 definition order within each group. */
kono
parents: 67
diff changeset
822 htab_traverse (modes.iterators, add_current_iterators, NULL);
kono
parents: 67
diff changeset
823 htab_traverse (codes.iterators, add_current_iterators, NULL);
kono
parents: 67
diff changeset
824 htab_traverse (ints.iterators, add_current_iterators, NULL);
kono
parents: 67
diff changeset
825 htab_traverse (substs.iterators, add_current_iterators, NULL);
kono
parents: 67
diff changeset
826 gcc_assert (!current_iterators.is_empty ());
kono
parents: 67
diff changeset
827
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
828 /* Check whether this is a '@' overloaded pattern. */
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
829 auto_vec<mapping *, 16> iterators;
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
830 overloaded_name *oname
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
831 = rtx_reader_ptr->handle_overloaded_name (original, &iterators);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
832
111
kono
parents: 67
diff changeset
833 for (;;)
kono
parents: 67
diff changeset
834 {
kono
parents: 67
diff changeset
835 /* Apply the current iterator values. Accumulate a condition to
kono
parents: 67
diff changeset
836 say when the resulting rtx can be used. */
kono
parents: 67
diff changeset
837 condition = "";
kono
parents: 67
diff changeset
838 FOR_EACH_VEC_ELT (iterator_uses, i, iuse)
kono
parents: 67
diff changeset
839 {
kono
parents: 67
diff changeset
840 if (iuse->iterator->group == &substs)
kono
parents: 67
diff changeset
841 continue;
kono
parents: 67
diff changeset
842 v = iuse->iterator->current_value;
kono
parents: 67
diff changeset
843 iuse->iterator->group->apply_iterator (iuse->x, iuse->index,
kono
parents: 67
diff changeset
844 v->number);
kono
parents: 67
diff changeset
845 condition = rtx_reader_ptr->join_c_conditions (condition, v->string);
kono
parents: 67
diff changeset
846 }
kono
parents: 67
diff changeset
847 apply_attribute_uses ();
kono
parents: 67
diff changeset
848 x = rtx_reader_ptr->copy_rtx_for_iterators (original);
kono
parents: 67
diff changeset
849 add_condition_to_rtx (x, condition);
kono
parents: 67
diff changeset
850
kono
parents: 67
diff changeset
851 /* We apply subst iterator after RTL-template is copied, as during
kono
parents: 67
diff changeset
852 subst-iterator processing, we could add an attribute to the
kono
parents: 67
diff changeset
853 RTL-template, and we don't want to do it in the original one. */
kono
parents: 67
diff changeset
854 FOR_EACH_VEC_ELT (iterator_uses, i, iuse)
kono
parents: 67
diff changeset
855 {
kono
parents: 67
diff changeset
856 v = iuse->iterator->current_value;
kono
parents: 67
diff changeset
857 if (iuse->iterator->group == &substs)
kono
parents: 67
diff changeset
858 {
kono
parents: 67
diff changeset
859 iuse->x = x;
kono
parents: 67
diff changeset
860 iuse->index = 0;
kono
parents: 67
diff changeset
861 current_iterator_name = iuse->iterator->name;
kono
parents: 67
diff changeset
862 iuse->iterator->group->apply_iterator (iuse->x, iuse->index,
kono
parents: 67
diff changeset
863 v->number);
kono
parents: 67
diff changeset
864 }
kono
parents: 67
diff changeset
865 }
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
866
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
867 if (oname)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
868 add_overload_instance (oname, iterators, x);
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
869
111
kono
parents: 67
diff changeset
870 /* Add the new rtx to the end of the queue. */
kono
parents: 67
diff changeset
871 queue->safe_push (x);
kono
parents: 67
diff changeset
872
kono
parents: 67
diff changeset
873 /* Lexicographically increment the iterator value sequence.
kono
parents: 67
diff changeset
874 That is, cycle through iterator values, starting from the right,
kono
parents: 67
diff changeset
875 and stopping when one of them doesn't wrap around. */
kono
parents: 67
diff changeset
876 i = current_iterators.length ();
kono
parents: 67
diff changeset
877 for (;;)
kono
parents: 67
diff changeset
878 {
kono
parents: 67
diff changeset
879 if (i == 0)
kono
parents: 67
diff changeset
880 return;
kono
parents: 67
diff changeset
881 i--;
kono
parents: 67
diff changeset
882 iterator = current_iterators[i];
kono
parents: 67
diff changeset
883 iterator->current_value = iterator->current_value->next;
kono
parents: 67
diff changeset
884 if (iterator->current_value)
kono
parents: 67
diff changeset
885 break;
kono
parents: 67
diff changeset
886 iterator->current_value = iterator->values;
kono
parents: 67
diff changeset
887 }
kono
parents: 67
diff changeset
888 }
kono
parents: 67
diff changeset
889 }
kono
parents: 67
diff changeset
890 #endif /* #ifdef GENERATOR_FILE */
kono
parents: 67
diff changeset
891
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
892 /* Add a new "mapping" structure to hashtable TABLE. NAME is the name
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
893 of the mapping and GROUP is the group to which it belongs. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
894
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
895 static struct mapping *
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
896 add_mapping (struct iterator_group *group, htab_t table, const char *name)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
897 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
898 struct mapping *m;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
899 void **slot;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
900
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
901 m = XNEW (struct mapping);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
902 m->name = xstrdup (name);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
903 m->group = group;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
904 m->values = 0;
111
kono
parents: 67
diff changeset
905 m->current_value = NULL;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
906
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
907 slot = htab_find_slot (table, m, INSERT);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
908 if (*slot != 0)
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
909 fatal_with_file_and_line ("`%s' already defined", name);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
910
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
911 *slot = m;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
912 return m;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
913 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
914
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
915 /* Add the pair (NUMBER, STRING) to a list of map_value structures.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
916 END_PTR points to the current null terminator for the list; return
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
917 a pointer the new null terminator. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
918
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
919 static struct map_value **
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
920 add_map_value (struct map_value **end_ptr, int number, const char *string)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
921 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
922 struct map_value *value;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
923
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
924 value = XNEW (struct map_value);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
925 value->next = 0;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
926 value->number = number;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
927 value->string = string;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
928
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
929 *end_ptr = value;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
930 return &value->next;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
931 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
932
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
933 /* Do one-time initialization of the mode and code attributes. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
934
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
935 static void
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
936 initialize_iterators (void)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
937 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
938 struct mapping *lower, *upper;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
939 struct map_value **lower_ptr, **upper_ptr;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
940 char *copy, *p;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
941 int i;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
942
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
943 modes.attrs = htab_create (13, leading_string_hash, leading_string_eq_p, 0);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
944 modes.iterators = htab_create (13, leading_string_hash,
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
945 leading_string_eq_p, 0);
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
946 modes.type = "machine_mode";
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
947 modes.find_builtin = find_mode;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
948 modes.apply_iterator = apply_mode_iterator;
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
949 modes.get_c_token = get_mode_token;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
950
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
951 codes.attrs = htab_create (13, leading_string_hash, leading_string_eq_p, 0);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
952 codes.iterators = htab_create (13, leading_string_hash,
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
953 leading_string_eq_p, 0);
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
954 codes.type = "rtx_code";
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
955 codes.find_builtin = find_code;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
956 codes.apply_iterator = apply_code_iterator;
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
957 codes.get_c_token = get_code_token;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
958
111
kono
parents: 67
diff changeset
959 ints.attrs = htab_create (13, leading_string_hash, leading_string_eq_p, 0);
kono
parents: 67
diff changeset
960 ints.iterators = htab_create (13, leading_string_hash,
kono
parents: 67
diff changeset
961 leading_string_eq_p, 0);
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
962 ints.type = "int";
111
kono
parents: 67
diff changeset
963 ints.find_builtin = find_int;
kono
parents: 67
diff changeset
964 ints.apply_iterator = apply_int_iterator;
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
965 ints.get_c_token = get_int_token;
111
kono
parents: 67
diff changeset
966
kono
parents: 67
diff changeset
967 substs.attrs = htab_create (13, leading_string_hash, leading_string_eq_p, 0);
kono
parents: 67
diff changeset
968 substs.iterators = htab_create (13, leading_string_hash,
kono
parents: 67
diff changeset
969 leading_string_eq_p, 0);
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
970 substs.type = "int";
111
kono
parents: 67
diff changeset
971 substs.find_builtin = find_int; /* We don't use it, anyway. */
kono
parents: 67
diff changeset
972 #ifdef GENERATOR_FILE
kono
parents: 67
diff changeset
973 substs.apply_iterator = apply_subst_iterator;
kono
parents: 67
diff changeset
974 #endif
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
975 substs.get_c_token = get_int_token;
111
kono
parents: 67
diff changeset
976
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
977 lower = add_mapping (&modes, modes.attrs, "mode");
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
978 upper = add_mapping (&modes, modes.attrs, "MODE");
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
979 lower_ptr = &lower->values;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
980 upper_ptr = &upper->values;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
981 for (i = 0; i < MAX_MACHINE_MODE; i++)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
982 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
983 copy = xstrdup (GET_MODE_NAME (i));
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
984 for (p = copy; *p != 0; p++)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
985 *p = TOLOWER (*p);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
986
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
987 upper_ptr = add_map_value (upper_ptr, i, GET_MODE_NAME (i));
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
988 lower_ptr = add_map_value (lower_ptr, i, copy);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
989 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
990
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
991 lower = add_mapping (&codes, codes.attrs, "code");
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
992 upper = add_mapping (&codes, codes.attrs, "CODE");
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
993 lower_ptr = &lower->values;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
994 upper_ptr = &upper->values;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
995 for (i = 0; i < NUM_RTX_CODE; i++)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
996 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
997 copy = xstrdup (GET_RTX_NAME (i));
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
998 for (p = copy; *p != 0; p++)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
999 *p = TOUPPER (*p);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1000
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1001 lower_ptr = add_map_value (lower_ptr, i, GET_RTX_NAME (i));
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1002 upper_ptr = add_map_value (upper_ptr, i, copy);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1003 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1004 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1005
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1006 /* Provide a version of a function to read a long long if the system does
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1007 not provide one. */
111
kono
parents: 67
diff changeset
1008 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !HAVE_DECL_ATOLL && !defined(HAVE_ATOQ)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1009 HOST_WIDE_INT atoll (const char *);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1010
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1011 HOST_WIDE_INT
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1012 atoll (const char *p)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1013 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1014 int neg = 0;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1015 HOST_WIDE_INT tmp_wide;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1016
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1017 while (ISSPACE (*p))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1018 p++;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1019 if (*p == '-')
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1020 neg = 1, p++;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1021 else if (*p == '+')
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1022 p++;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1023
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1024 tmp_wide = 0;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1025 while (ISDIGIT (*p))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1026 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1027 HOST_WIDE_INT new_wide = tmp_wide*10 + (*p - '0');
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1028 if (new_wide < tmp_wide)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1029 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1030 /* Return INT_MAX equiv on overflow. */
111
kono
parents: 67
diff changeset
1031 tmp_wide = HOST_WIDE_INT_M1U >> 1;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1032 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1033 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1034 tmp_wide = new_wide;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1035 p++;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1036 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1037
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1038 if (neg)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1039 tmp_wide = -tmp_wide;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1040 return tmp_wide;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1041 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1042 #endif
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1043
111
kono
parents: 67
diff changeset
1044
kono
parents: 67
diff changeset
1045 #ifdef GENERATOR_FILE
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1046 /* Process a define_conditions directive, starting with the optional
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1047 space after the "define_conditions". The directive looks like this:
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1048
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1049 (define_conditions [
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1050 (number "string")
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1051 (number "string")
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1052 ...
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1053 ])
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1054
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1055 It's not intended to appear in machine descriptions. It is
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1056 generated by (the program generated by) genconditions.c, and
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1057 slipped in at the beginning of the sequence of MD files read by
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1058 most of the other generators. */
111
kono
parents: 67
diff changeset
1059 void
kono
parents: 67
diff changeset
1060 md_reader::read_conditions ()
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1061 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1062 int c;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1063
111
kono
parents: 67
diff changeset
1064 require_char_ws ('[');
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1065
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1066 while ( (c = read_skip_spaces ()) != ']')
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1067 {
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1068 struct md_name name;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1069 char *expr;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1070 int value;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1071
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1072 if (c != '(')
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1073 fatal_expected_char ('(', c);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1074
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1075 read_name (&name);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1076 validate_const_int (name.string);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1077 value = atoi (name.string);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1078
111
kono
parents: 67
diff changeset
1079 require_char_ws ('"');
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1080 expr = read_quoted_string ();
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1081
111
kono
parents: 67
diff changeset
1082 require_char_ws (')');
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1083
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1084 add_c_test (expr, value);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1085 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1086 }
111
kono
parents: 67
diff changeset
1087 #endif /* #ifdef GENERATOR_FILE */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1088
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1089 static void
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1090 validate_const_int (const char *string)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1091 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1092 const char *cp;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1093 int valid = 1;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1094
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1095 cp = string;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1096 while (*cp && ISSPACE (*cp))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1097 cp++;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1098 if (*cp == '-' || *cp == '+')
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1099 cp++;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1100 if (*cp == 0)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1101 valid = 0;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1102 for (; *cp; cp++)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1103 if (! ISDIGIT (*cp))
111
kono
parents: 67
diff changeset
1104 {
kono
parents: 67
diff changeset
1105 valid = 0;
kono
parents: 67
diff changeset
1106 break;
kono
parents: 67
diff changeset
1107 }
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1108 if (!valid)
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1109 fatal_with_file_and_line ("invalid decimal constant \"%s\"\n", string);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1110 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1111
111
kono
parents: 67
diff changeset
1112 static void
kono
parents: 67
diff changeset
1113 validate_const_wide_int (const char *string)
kono
parents: 67
diff changeset
1114 {
kono
parents: 67
diff changeset
1115 const char *cp;
kono
parents: 67
diff changeset
1116 int valid = 1;
kono
parents: 67
diff changeset
1117
kono
parents: 67
diff changeset
1118 cp = string;
kono
parents: 67
diff changeset
1119 while (*cp && ISSPACE (*cp))
kono
parents: 67
diff changeset
1120 cp++;
kono
parents: 67
diff changeset
1121 /* Skip the leading 0x. */
kono
parents: 67
diff changeset
1122 if (cp[0] == '0' || cp[1] == 'x')
kono
parents: 67
diff changeset
1123 cp += 2;
kono
parents: 67
diff changeset
1124 else
kono
parents: 67
diff changeset
1125 valid = 0;
kono
parents: 67
diff changeset
1126 if (*cp == 0)
kono
parents: 67
diff changeset
1127 valid = 0;
kono
parents: 67
diff changeset
1128 for (; *cp; cp++)
kono
parents: 67
diff changeset
1129 if (! ISXDIGIT (*cp))
kono
parents: 67
diff changeset
1130 valid = 0;
kono
parents: 67
diff changeset
1131 if (!valid)
kono
parents: 67
diff changeset
1132 fatal_with_file_and_line ("invalid hex constant \"%s\"\n", string);
kono
parents: 67
diff changeset
1133 }
kono
parents: 67
diff changeset
1134
kono
parents: 67
diff changeset
1135 /* Record that X uses iterator ITERATOR. If the use is in an operand
kono
parents: 67
diff changeset
1136 of X, INDEX is the index of that operand, otherwise it is ignored. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1137
111
kono
parents: 67
diff changeset
1138 static void
kono
parents: 67
diff changeset
1139 record_iterator_use (struct mapping *iterator, rtx x, unsigned int index)
kono
parents: 67
diff changeset
1140 {
kono
parents: 67
diff changeset
1141 struct iterator_use iuse = {iterator, x, index};
kono
parents: 67
diff changeset
1142 iterator_uses.safe_push (iuse);
kono
parents: 67
diff changeset
1143 }
kono
parents: 67
diff changeset
1144
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1145 /* Record that X uses attribute VALUE at location LOC, where VALUE must
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1146 match a built-in value from group GROUP. If the use is in an operand
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1147 of X, INDEX is the index of that operand, otherwise it is ignored. */
111
kono
parents: 67
diff changeset
1148
kono
parents: 67
diff changeset
1149 static void
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1150 record_attribute_use (struct iterator_group *group, file_location loc, rtx x,
111
kono
parents: 67
diff changeset
1151 unsigned int index, const char *value)
kono
parents: 67
diff changeset
1152 {
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1153 struct attribute_use ause = {group, loc, value, x, index};
111
kono
parents: 67
diff changeset
1154 attribute_uses.safe_push (ause);
kono
parents: 67
diff changeset
1155 }
kono
parents: 67
diff changeset
1156
kono
parents: 67
diff changeset
1157 /* Interpret NAME as either a built-in value, iterator or attribute
kono
parents: 67
diff changeset
1158 for group GROUP. X and INDEX are the values to pass to GROUP's
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1159 apply_iterator callback. LOC is the location of the use. */
111
kono
parents: 67
diff changeset
1160
kono
parents: 67
diff changeset
1161 void
kono
parents: 67
diff changeset
1162 md_reader::record_potential_iterator_use (struct iterator_group *group,
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1163 file_location loc,
111
kono
parents: 67
diff changeset
1164 rtx x, unsigned int index,
kono
parents: 67
diff changeset
1165 const char *name)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1166 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1167 struct mapping *m;
111
kono
parents: 67
diff changeset
1168 size_t len;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1169
111
kono
parents: 67
diff changeset
1170 len = strlen (name);
kono
parents: 67
diff changeset
1171 if (name[0] == '<' && name[len - 1] == '>')
kono
parents: 67
diff changeset
1172 {
kono
parents: 67
diff changeset
1173 /* Copy the attribute string into permanent storage, without the
kono
parents: 67
diff changeset
1174 angle brackets around it. */
kono
parents: 67
diff changeset
1175 obstack_grow0 (&m_string_obstack, name + 1, len - 2);
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1176 record_attribute_use (group, loc, x, index,
111
kono
parents: 67
diff changeset
1177 XOBFINISH (&m_string_obstack, char *));
kono
parents: 67
diff changeset
1178 }
kono
parents: 67
diff changeset
1179 else
kono
parents: 67
diff changeset
1180 {
kono
parents: 67
diff changeset
1181 m = (struct mapping *) htab_find (group->iterators, &name);
kono
parents: 67
diff changeset
1182 if (m != 0)
kono
parents: 67
diff changeset
1183 record_iterator_use (m, x, index);
kono
parents: 67
diff changeset
1184 else
kono
parents: 67
diff changeset
1185 group->apply_iterator (x, index, group->find_builtin (name));
kono
parents: 67
diff changeset
1186 }
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1187 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1188
111
kono
parents: 67
diff changeset
1189 #ifdef GENERATOR_FILE
kono
parents: 67
diff changeset
1190
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1191 /* Finish reading a declaration of the form:
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1192
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1193 (define... <name> [<value1> ... <valuen>])
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1194
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1195 from the MD file, where each <valuei> is either a bare symbol name or a
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1196 "(<name> <string>)" pair. The "(define..." part has already been read.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1197
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1198 Represent the declaration as a "mapping" structure; add it to TABLE
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1199 (which belongs to GROUP) and return it. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1200
111
kono
parents: 67
diff changeset
1201 struct mapping *
kono
parents: 67
diff changeset
1202 md_reader::read_mapping (struct iterator_group *group, htab_t table)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1203 {
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1204 struct md_name name;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1205 struct mapping *m;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1206 struct map_value **end_ptr;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1207 const char *string;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1208 int number, c;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1209
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1210 /* Read the mapping name and create a structure for it. */
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1211 read_name (&name);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1212 m = add_mapping (group, table, name.string);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1213
111
kono
parents: 67
diff changeset
1214 require_char_ws ('[');
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1215
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1216 /* Read each value. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1217 end_ptr = &m->values;
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1218 c = read_skip_spaces ();
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1219 do
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1220 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1221 if (c != '(')
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1222 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1223 /* A bare symbol name that is implicitly paired to an
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1224 empty string. */
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1225 unread_char (c);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1226 read_name (&name);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1227 string = "";
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1228 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1229 else
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1230 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1231 /* A "(name string)" pair. */
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1232 read_name (&name);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1233 string = read_string (false);
111
kono
parents: 67
diff changeset
1234 require_char_ws (')');
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1235 }
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1236 number = group->find_builtin (name.string);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1237 end_ptr = add_map_value (end_ptr, number, string);
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1238 c = read_skip_spaces ();
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1239 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1240 while (c != ']');
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1241
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1242 return m;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1243 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1244
111
kono
parents: 67
diff changeset
1245 /* For iterator with name ATTR_NAME generate define_attr with values
kono
parents: 67
diff changeset
1246 'yes' and 'no'. This attribute is used to mark templates to which
kono
parents: 67
diff changeset
1247 define_subst ATTR_NAME should be applied. This attribute is set and
kono
parents: 67
diff changeset
1248 defined implicitly and automatically. */
kono
parents: 67
diff changeset
1249 static void
kono
parents: 67
diff changeset
1250 add_define_attr_for_define_subst (const char *attr_name, vec<rtx> *queue)
kono
parents: 67
diff changeset
1251 {
kono
parents: 67
diff changeset
1252 rtx const_str, return_rtx;
kono
parents: 67
diff changeset
1253
kono
parents: 67
diff changeset
1254 return_rtx = rtx_alloc (DEFINE_ATTR);
kono
parents: 67
diff changeset
1255 PUT_CODE (return_rtx, DEFINE_ATTR);
kono
parents: 67
diff changeset
1256
kono
parents: 67
diff changeset
1257 const_str = rtx_alloc (CONST_STRING);
kono
parents: 67
diff changeset
1258 PUT_CODE (const_str, CONST_STRING);
kono
parents: 67
diff changeset
1259 XSTR (const_str, 0) = xstrdup ("no");
kono
parents: 67
diff changeset
1260
kono
parents: 67
diff changeset
1261 XSTR (return_rtx, 0) = xstrdup (attr_name);
kono
parents: 67
diff changeset
1262 XSTR (return_rtx, 1) = xstrdup ("no,yes");
kono
parents: 67
diff changeset
1263 XEXP (return_rtx, 2) = const_str;
kono
parents: 67
diff changeset
1264
kono
parents: 67
diff changeset
1265 queue->safe_push (return_rtx);
kono
parents: 67
diff changeset
1266 }
kono
parents: 67
diff changeset
1267
kono
parents: 67
diff changeset
1268 /* This routine generates DEFINE_SUBST_ATTR expression with operands
kono
parents: 67
diff changeset
1269 ATTR_OPERANDS and places it to QUEUE. */
kono
parents: 67
diff changeset
1270 static void
kono
parents: 67
diff changeset
1271 add_define_subst_attr (const char **attr_operands, vec<rtx> *queue)
kono
parents: 67
diff changeset
1272 {
kono
parents: 67
diff changeset
1273 rtx return_rtx;
kono
parents: 67
diff changeset
1274 int i;
kono
parents: 67
diff changeset
1275
kono
parents: 67
diff changeset
1276 return_rtx = rtx_alloc (DEFINE_SUBST_ATTR);
kono
parents: 67
diff changeset
1277 PUT_CODE (return_rtx, DEFINE_SUBST_ATTR);
kono
parents: 67
diff changeset
1278
kono
parents: 67
diff changeset
1279 for (i = 0; i < 4; i++)
kono
parents: 67
diff changeset
1280 XSTR (return_rtx, i) = xstrdup (attr_operands[i]);
kono
parents: 67
diff changeset
1281
kono
parents: 67
diff changeset
1282 queue->safe_push (return_rtx);
kono
parents: 67
diff changeset
1283 }
kono
parents: 67
diff changeset
1284
kono
parents: 67
diff changeset
1285 /* Read define_subst_attribute construction. It has next form:
kono
parents: 67
diff changeset
1286 (define_subst_attribute <attribute_name> <iterator_name> <value1> <value2>)
kono
parents: 67
diff changeset
1287 Attribute is substituted with value1 when no subst is applied and with
kono
parents: 67
diff changeset
1288 value2 in the opposite case.
kono
parents: 67
diff changeset
1289 Attributes are added to SUBST_ATTRS_TABLE.
kono
parents: 67
diff changeset
1290 In case the iterator is encountered for the first time, it's added to
kono
parents: 67
diff changeset
1291 SUBST_ITERS_TABLE. Also, implicit define_attr is generated. */
kono
parents: 67
diff changeset
1292
kono
parents: 67
diff changeset
1293 static void
kono
parents: 67
diff changeset
1294 read_subst_mapping (htab_t subst_iters_table, htab_t subst_attrs_table,
kono
parents: 67
diff changeset
1295 vec<rtx> *queue)
kono
parents: 67
diff changeset
1296 {
kono
parents: 67
diff changeset
1297 struct mapping *m;
kono
parents: 67
diff changeset
1298 struct map_value **end_ptr;
kono
parents: 67
diff changeset
1299 const char *attr_operands[4];
kono
parents: 67
diff changeset
1300 int i;
kono
parents: 67
diff changeset
1301
kono
parents: 67
diff changeset
1302 for (i = 0; i < 4; i++)
kono
parents: 67
diff changeset
1303 attr_operands[i] = rtx_reader_ptr->read_string (false);
kono
parents: 67
diff changeset
1304
kono
parents: 67
diff changeset
1305 add_define_subst_attr (attr_operands, queue);
kono
parents: 67
diff changeset
1306
kono
parents: 67
diff changeset
1307 bind_subst_iter_and_attr (attr_operands[1], attr_operands[0]);
kono
parents: 67
diff changeset
1308
kono
parents: 67
diff changeset
1309 m = (struct mapping *) htab_find (substs.iterators, &attr_operands[1]);
kono
parents: 67
diff changeset
1310 if (!m)
kono
parents: 67
diff changeset
1311 {
kono
parents: 67
diff changeset
1312 m = add_mapping (&substs, subst_iters_table, attr_operands[1]);
kono
parents: 67
diff changeset
1313 end_ptr = &m->values;
kono
parents: 67
diff changeset
1314 end_ptr = add_map_value (end_ptr, 1, "");
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1315 add_map_value (end_ptr, 2, "");
111
kono
parents: 67
diff changeset
1316
kono
parents: 67
diff changeset
1317 add_define_attr_for_define_subst (attr_operands[1], queue);
kono
parents: 67
diff changeset
1318 }
kono
parents: 67
diff changeset
1319
kono
parents: 67
diff changeset
1320 m = add_mapping (&substs, subst_attrs_table, attr_operands[0]);
kono
parents: 67
diff changeset
1321 end_ptr = &m->values;
kono
parents: 67
diff changeset
1322 end_ptr = add_map_value (end_ptr, 1, attr_operands[2]);
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1323 add_map_value (end_ptr, 2, attr_operands[3]);
111
kono
parents: 67
diff changeset
1324 }
kono
parents: 67
diff changeset
1325
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1326 /* Check newly-created code iterator ITERATOR to see whether every code has the
111
kono
parents: 67
diff changeset
1327 same format. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1328
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1329 static void
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1330 check_code_iterator (struct mapping *iterator)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1331 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1332 struct map_value *v;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1333 enum rtx_code bellwether;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1334
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1335 bellwether = (enum rtx_code) iterator->values->number;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1336 for (v = iterator->values->next; v != 0; v = v->next)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1337 if (strcmp (GET_RTX_FORMAT (bellwether), GET_RTX_FORMAT (v->number)) != 0)
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1338 fatal_with_file_and_line ("code iterator `%s' combines "
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1339 "`%s' and `%s', which have different "
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1340 "rtx formats", iterator->name,
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1341 GET_RTX_NAME (bellwether),
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1342 GET_RTX_NAME (v->number));
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1343 }
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1344
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1345 /* Check that all values of attribute ATTR are rtx codes that have a
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1346 consistent format. Return a representative code. */
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1347
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1348 static rtx_code
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1349 check_code_attribute (mapping *attr)
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1350 {
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1351 rtx_code bellwether = UNKNOWN;
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1352 for (map_value *v = attr->values; v != 0; v = v->next)
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1353 {
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1354 rtx_code code = maybe_find_code (v->string);
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1355 if (code == UNKNOWN)
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1356 fatal_with_file_and_line ("code attribute `%s' contains "
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1357 "unrecognized rtx code `%s'",
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1358 attr->name, v->string);
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1359 if (bellwether == UNKNOWN)
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1360 bellwether = code;
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1361 else if (strcmp (GET_RTX_FORMAT (bellwether),
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1362 GET_RTX_FORMAT (code)) != 0)
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1363 fatal_with_file_and_line ("code attribute `%s' combines "
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1364 "`%s' and `%s', which have different "
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1365 "rtx formats", attr->name,
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1366 GET_RTX_NAME (bellwether),
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1367 GET_RTX_NAME (code));
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1368 }
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1369 return bellwether;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1370 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1371
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1372 /* Read an rtx-related declaration from the MD file, given that it
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1373 starts with directive name RTX_NAME. Return true if it expands to
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1374 one or more rtxes (as defined by rtx.def). When returning true,
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1375 store the list of rtxes as an EXPR_LIST in *X. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1376
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1377 bool
111
kono
parents: 67
diff changeset
1378 rtx_reader::read_rtx (const char *rtx_name, vec<rtx> *rtxen)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1379 {
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1380 /* Handle various rtx-related declarations that aren't themselves
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1381 encoded as rtxes. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1382 if (strcmp (rtx_name, "define_conditions") == 0)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1383 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1384 read_conditions ();
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1385 return false;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1386 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1387 if (strcmp (rtx_name, "define_mode_attr") == 0)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1388 {
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1389 read_mapping (&modes, modes.attrs);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1390 return false;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1391 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1392 if (strcmp (rtx_name, "define_mode_iterator") == 0)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1393 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1394 read_mapping (&modes, modes.iterators);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1395 return false;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1396 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1397 if (strcmp (rtx_name, "define_code_attr") == 0)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1398 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1399 read_mapping (&codes, codes.attrs);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1400 return false;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1401 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1402 if (strcmp (rtx_name, "define_code_iterator") == 0)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1403 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1404 check_code_iterator (read_mapping (&codes, codes.iterators));
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1405 return false;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1406 }
111
kono
parents: 67
diff changeset
1407 if (strcmp (rtx_name, "define_int_attr") == 0)
kono
parents: 67
diff changeset
1408 {
kono
parents: 67
diff changeset
1409 read_mapping (&ints, ints.attrs);
kono
parents: 67
diff changeset
1410 return false;
kono
parents: 67
diff changeset
1411 }
kono
parents: 67
diff changeset
1412 if (strcmp (rtx_name, "define_int_iterator") == 0)
kono
parents: 67
diff changeset
1413 {
kono
parents: 67
diff changeset
1414 read_mapping (&ints, ints.iterators);
kono
parents: 67
diff changeset
1415 return false;
kono
parents: 67
diff changeset
1416 }
kono
parents: 67
diff changeset
1417 if (strcmp (rtx_name, "define_subst_attr") == 0)
kono
parents: 67
diff changeset
1418 {
kono
parents: 67
diff changeset
1419 read_subst_mapping (substs.iterators, substs.attrs, rtxen);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1420
111
kono
parents: 67
diff changeset
1421 /* READ_SUBST_MAPPING could generate a new DEFINE_ATTR. Return
kono
parents: 67
diff changeset
1422 TRUE to process it. */
kono
parents: 67
diff changeset
1423 return true;
kono
parents: 67
diff changeset
1424 }
kono
parents: 67
diff changeset
1425
kono
parents: 67
diff changeset
1426 apply_iterators (rtx_reader_ptr->read_rtx_code (rtx_name), rtxen);
kono
parents: 67
diff changeset
1427 iterator_uses.truncate (0);
kono
parents: 67
diff changeset
1428 attribute_uses.truncate (0);
kono
parents: 67
diff changeset
1429
kono
parents: 67
diff changeset
1430 return true;
kono
parents: 67
diff changeset
1431 }
kono
parents: 67
diff changeset
1432
kono
parents: 67
diff changeset
1433 #endif /* #ifdef GENERATOR_FILE */
kono
parents: 67
diff changeset
1434
kono
parents: 67
diff changeset
1435 /* Do one-time initialization. */
kono
parents: 67
diff changeset
1436
kono
parents: 67
diff changeset
1437 static void
kono
parents: 67
diff changeset
1438 one_time_initialization (void)
kono
parents: 67
diff changeset
1439 {
kono
parents: 67
diff changeset
1440 static bool initialized = false;
kono
parents: 67
diff changeset
1441
kono
parents: 67
diff changeset
1442 if (!initialized)
kono
parents: 67
diff changeset
1443 {
kono
parents: 67
diff changeset
1444 initialize_iterators ();
kono
parents: 67
diff changeset
1445 initialized = true;
kono
parents: 67
diff changeset
1446 }
kono
parents: 67
diff changeset
1447 }
kono
parents: 67
diff changeset
1448
kono
parents: 67
diff changeset
1449 /* Consume characters until encountering a character in TERMINATOR_CHARS,
kono
parents: 67
diff changeset
1450 consuming the terminator character if CONSUME_TERMINATOR is true.
kono
parents: 67
diff changeset
1451 Return all characters before the terminator as an allocated buffer. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1452
111
kono
parents: 67
diff changeset
1453 char *
kono
parents: 67
diff changeset
1454 rtx_reader::read_until (const char *terminator_chars, bool consume_terminator)
kono
parents: 67
diff changeset
1455 {
kono
parents: 67
diff changeset
1456 int ch = read_skip_spaces ();
kono
parents: 67
diff changeset
1457 unread_char (ch);
kono
parents: 67
diff changeset
1458 auto_vec<char> buf;
kono
parents: 67
diff changeset
1459 while (1)
kono
parents: 67
diff changeset
1460 {
kono
parents: 67
diff changeset
1461 ch = read_char ();
kono
parents: 67
diff changeset
1462 if (strchr (terminator_chars, ch))
kono
parents: 67
diff changeset
1463 {
kono
parents: 67
diff changeset
1464 if (!consume_terminator)
kono
parents: 67
diff changeset
1465 unread_char (ch);
kono
parents: 67
diff changeset
1466 break;
kono
parents: 67
diff changeset
1467 }
kono
parents: 67
diff changeset
1468 buf.safe_push (ch);
kono
parents: 67
diff changeset
1469 }
kono
parents: 67
diff changeset
1470 buf.safe_push ('\0');
kono
parents: 67
diff changeset
1471 return xstrdup (buf.address ());
kono
parents: 67
diff changeset
1472 }
kono
parents: 67
diff changeset
1473
kono
parents: 67
diff changeset
1474 /* Subroutine of read_rtx_code, for parsing zero or more flags. */
kono
parents: 67
diff changeset
1475
kono
parents: 67
diff changeset
1476 static void
kono
parents: 67
diff changeset
1477 read_flags (rtx return_rtx)
kono
parents: 67
diff changeset
1478 {
kono
parents: 67
diff changeset
1479 while (1)
kono
parents: 67
diff changeset
1480 {
kono
parents: 67
diff changeset
1481 int ch = read_char ();
kono
parents: 67
diff changeset
1482 if (ch != '/')
kono
parents: 67
diff changeset
1483 {
kono
parents: 67
diff changeset
1484 unread_char (ch);
kono
parents: 67
diff changeset
1485 break;
kono
parents: 67
diff changeset
1486 }
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1487
111
kono
parents: 67
diff changeset
1488 int flag_char = read_char ();
kono
parents: 67
diff changeset
1489 switch (flag_char)
kono
parents: 67
diff changeset
1490 {
kono
parents: 67
diff changeset
1491 case 's':
kono
parents: 67
diff changeset
1492 RTX_FLAG (return_rtx, in_struct) = 1;
kono
parents: 67
diff changeset
1493 break;
kono
parents: 67
diff changeset
1494 case 'v':
kono
parents: 67
diff changeset
1495 RTX_FLAG (return_rtx, volatil) = 1;
kono
parents: 67
diff changeset
1496 break;
kono
parents: 67
diff changeset
1497 case 'u':
kono
parents: 67
diff changeset
1498 RTX_FLAG (return_rtx, unchanging) = 1;
kono
parents: 67
diff changeset
1499 break;
kono
parents: 67
diff changeset
1500 case 'f':
kono
parents: 67
diff changeset
1501 RTX_FLAG (return_rtx, frame_related) = 1;
kono
parents: 67
diff changeset
1502 break;
kono
parents: 67
diff changeset
1503 case 'j':
kono
parents: 67
diff changeset
1504 RTX_FLAG (return_rtx, jump) = 1;
kono
parents: 67
diff changeset
1505 break;
kono
parents: 67
diff changeset
1506 case 'c':
kono
parents: 67
diff changeset
1507 RTX_FLAG (return_rtx, call) = 1;
kono
parents: 67
diff changeset
1508 break;
kono
parents: 67
diff changeset
1509 case 'i':
kono
parents: 67
diff changeset
1510 RTX_FLAG (return_rtx, return_val) = 1;
kono
parents: 67
diff changeset
1511 break;
kono
parents: 67
diff changeset
1512 default:
kono
parents: 67
diff changeset
1513 fatal_with_file_and_line ("unrecognized flag: `%c'", flag_char);
kono
parents: 67
diff changeset
1514 }
kono
parents: 67
diff changeset
1515 }
kono
parents: 67
diff changeset
1516 }
kono
parents: 67
diff changeset
1517
kono
parents: 67
diff changeset
1518 /* Return the numeric value n for GET_REG_NOTE_NAME (n) for STRING,
kono
parents: 67
diff changeset
1519 or fail if STRING isn't recognized. */
kono
parents: 67
diff changeset
1520
kono
parents: 67
diff changeset
1521 static int
kono
parents: 67
diff changeset
1522 parse_reg_note_name (const char *string)
kono
parents: 67
diff changeset
1523 {
kono
parents: 67
diff changeset
1524 for (int i = 0; i < REG_NOTE_MAX; i++)
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
1525 if (strcmp (string, GET_REG_NOTE_NAME (i)) == 0)
111
kono
parents: 67
diff changeset
1526 return i;
kono
parents: 67
diff changeset
1527 fatal_with_file_and_line ("unrecognized REG_NOTE name: `%s'", string);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1528 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1529
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1530 /* Allocate an rtx for code NAME. If NAME is a code iterator or code
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1531 attribute, record its use for later and use one of its possible
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1532 values as an interim rtx code. */
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1533
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1534 rtx
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1535 rtx_reader::rtx_alloc_for_name (const char *name)
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1536 {
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1537 #ifdef GENERATOR_FILE
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1538 size_t len = strlen (name);
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1539 if (name[0] == '<' && name[len - 1] == '>')
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1540 {
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1541 /* Copy the attribute string into permanent storage, without the
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1542 angle brackets around it. */
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1543 obstack *strings = get_string_obstack ();
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1544 obstack_grow0 (strings, name + 1, len - 2);
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1545 char *deferred_name = XOBFINISH (strings, char *);
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1546
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1547 /* Find the name of the attribute. */
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1548 const char *attr = strchr (deferred_name, ':');
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1549 if (!attr)
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1550 attr = deferred_name;
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1551
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1552 /* Find the attribute itself. */
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1553 mapping *m = (mapping *) htab_find (codes.attrs, &attr);
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1554 if (!m)
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1555 fatal_with_file_and_line ("unknown code attribute `%s'", attr);
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1556
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1557 /* Pick the first possible code for now, and record the attribute
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1558 use for later. */
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1559 rtx x = rtx_alloc (check_code_attribute (m));
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1560 record_attribute_use (&codes, get_current_location (),
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1561 x, 0, deferred_name);
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1562 return x;
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1563 }
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1564
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1565 mapping *iterator = (mapping *) htab_find (codes.iterators, &name);
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1566 if (iterator != 0)
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1567 {
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1568 /* Pick the first possible code for now, and record the iterator
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1569 use for later. */
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1570 rtx x = rtx_alloc (rtx_code (iterator->values->number));
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1571 record_iterator_use (iterator, x, 0);
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1572 return x;
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1573 }
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1574 #endif
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1575
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1576 return rtx_alloc (rtx_code (codes.find_builtin (name)));
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1577 }
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1578
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1579 /* Subroutine of read_rtx and read_nested_rtx. CODE_NAME is the name of
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1580 either an rtx code or a code iterator. Parse the rest of the rtx and
111
kono
parents: 67
diff changeset
1581 return it. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1582
111
kono
parents: 67
diff changeset
1583 rtx
kono
parents: 67
diff changeset
1584 rtx_reader::read_rtx_code (const char *code_name)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1585 {
111
kono
parents: 67
diff changeset
1586 RTX_CODE code;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1587 const char *format_ptr;
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1588 struct md_name name;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1589 rtx return_rtx;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1590 int c;
111
kono
parents: 67
diff changeset
1591 long reuse_id = -1;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1592
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1593 /* Linked list structure for making RTXs: */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1594 struct rtx_list
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1595 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1596 struct rtx_list *next;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1597 rtx value; /* Value of this node. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1598 };
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1599
111
kono
parents: 67
diff changeset
1600 /* Handle reuse_rtx ids e.g. "(0|scratch:DI)". */
kono
parents: 67
diff changeset
1601 if (ISDIGIT (code_name[0]))
kono
parents: 67
diff changeset
1602 {
kono
parents: 67
diff changeset
1603 reuse_id = atoi (code_name);
kono
parents: 67
diff changeset
1604 while (char ch = *code_name++)
kono
parents: 67
diff changeset
1605 if (ch == '|')
kono
parents: 67
diff changeset
1606 break;
kono
parents: 67
diff changeset
1607 }
kono
parents: 67
diff changeset
1608
kono
parents: 67
diff changeset
1609 /* Handle "reuse_rtx". */
kono
parents: 67
diff changeset
1610 if (strcmp (code_name, "reuse_rtx") == 0)
kono
parents: 67
diff changeset
1611 {
kono
parents: 67
diff changeset
1612 read_name (&name);
kono
parents: 67
diff changeset
1613 unsigned idx = atoi (name.string);
kono
parents: 67
diff changeset
1614 /* Look it up by ID. */
kono
parents: 67
diff changeset
1615 gcc_assert (idx < m_reuse_rtx_by_id.length ());
kono
parents: 67
diff changeset
1616 return_rtx = m_reuse_rtx_by_id[idx];
kono
parents: 67
diff changeset
1617 return return_rtx;
kono
parents: 67
diff changeset
1618 }
kono
parents: 67
diff changeset
1619
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1620 /* If we end up with an insn expression then we free this space below. */
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1621 return_rtx = rtx_alloc_for_name (code_name);
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1622 code = GET_CODE (return_rtx);
111
kono
parents: 67
diff changeset
1623 format_ptr = GET_RTX_FORMAT (code);
kono
parents: 67
diff changeset
1624 memset (return_rtx, 0, RTX_CODE_SIZE (code));
kono
parents: 67
diff changeset
1625 PUT_CODE (return_rtx, code);
kono
parents: 67
diff changeset
1626
kono
parents: 67
diff changeset
1627 if (reuse_id != -1)
kono
parents: 67
diff changeset
1628 {
kono
parents: 67
diff changeset
1629 /* Store away for later reuse. */
kono
parents: 67
diff changeset
1630 m_reuse_rtx_by_id.safe_grow_cleared (reuse_id + 1);
kono
parents: 67
diff changeset
1631 m_reuse_rtx_by_id[reuse_id] = return_rtx;
kono
parents: 67
diff changeset
1632 }
kono
parents: 67
diff changeset
1633
kono
parents: 67
diff changeset
1634 /* Check for flags. */
kono
parents: 67
diff changeset
1635 read_flags (return_rtx);
kono
parents: 67
diff changeset
1636
kono
parents: 67
diff changeset
1637 /* Read REG_NOTE names for EXPR_LIST and INSN_LIST. */
kono
parents: 67
diff changeset
1638 if ((GET_CODE (return_rtx) == EXPR_LIST
kono
parents: 67
diff changeset
1639 || GET_CODE (return_rtx) == INSN_LIST
kono
parents: 67
diff changeset
1640 || GET_CODE (return_rtx) == INT_LIST)
kono
parents: 67
diff changeset
1641 && !m_in_call_function_usage)
kono
parents: 67
diff changeset
1642 {
kono
parents: 67
diff changeset
1643 char ch = read_char ();
kono
parents: 67
diff changeset
1644 if (ch == ':')
kono
parents: 67
diff changeset
1645 {
kono
parents: 67
diff changeset
1646 read_name (&name);
kono
parents: 67
diff changeset
1647 PUT_MODE_RAW (return_rtx,
kono
parents: 67
diff changeset
1648 (machine_mode)parse_reg_note_name (name.string));
kono
parents: 67
diff changeset
1649 }
kono
parents: 67
diff changeset
1650 else
kono
parents: 67
diff changeset
1651 unread_char (ch);
kono
parents: 67
diff changeset
1652 }
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1653
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1654 /* If what follows is `: mode ', read it and
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1655 store the mode in the rtx. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1656
111
kono
parents: 67
diff changeset
1657 c = read_skip_spaces ();
kono
parents: 67
diff changeset
1658 if (c == ':')
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1659 {
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1660 file_location loc = read_name (&name);
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
1661 record_potential_iterator_use (&modes, loc, return_rtx, 0, name.string);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1662 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1663 else
111
kono
parents: 67
diff changeset
1664 unread_char (c);
kono
parents: 67
diff changeset
1665
kono
parents: 67
diff changeset
1666 if (INSN_CHAIN_CODE_P (code))
kono
parents: 67
diff changeset
1667 {
kono
parents: 67
diff changeset
1668 read_name (&name);
kono
parents: 67
diff changeset
1669 INSN_UID (return_rtx) = atoi (name.string);
kono
parents: 67
diff changeset
1670 }
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1671
111
kono
parents: 67
diff changeset
1672 /* Use the format_ptr to parse the various operands of this rtx. */
kono
parents: 67
diff changeset
1673 for (int idx = 0; format_ptr[idx] != 0; idx++)
kono
parents: 67
diff changeset
1674 return_rtx = read_rtx_operand (return_rtx, idx);
kono
parents: 67
diff changeset
1675
kono
parents: 67
diff changeset
1676 /* Handle any additional information that after the regular fields
kono
parents: 67
diff changeset
1677 (e.g. when parsing function dumps). */
kono
parents: 67
diff changeset
1678 handle_any_trailing_information (return_rtx);
kono
parents: 67
diff changeset
1679
kono
parents: 67
diff changeset
1680 if (CONST_WIDE_INT_P (return_rtx))
kono
parents: 67
diff changeset
1681 {
kono
parents: 67
diff changeset
1682 read_name (&name);
kono
parents: 67
diff changeset
1683 validate_const_wide_int (name.string);