|
0
|
1 /* RTL reader for GCC.
|
|
|
2 Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002,
|
|
|
3 2003, 2004, 2005, 2007, 2008
|
|
|
4 Free Software Foundation, Inc.
|
|
|
5
|
|
|
6 This file is part of GCC.
|
|
|
7
|
|
|
8 GCC is free software; you can redistribute it and/or modify it under
|
|
|
9 the terms of the GNU General Public License as published by the Free
|
|
|
10 Software Foundation; either version 3, or (at your option) any later
|
|
|
11 version.
|
|
|
12
|
|
|
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
16 for more details.
|
|
|
17
|
|
|
18 You should have received a copy of the GNU General Public License
|
|
|
19 along with GCC; see the file COPYING3. If not see
|
|
|
20 <http://www.gnu.org/licenses/>. */
|
|
|
21
|
|
|
22 #include "bconfig.h"
|
|
|
23
|
|
|
24 /* Disable rtl checking; it conflicts with the iterator handling. */
|
|
|
25 #undef ENABLE_RTL_CHECKING
|
|
|
26
|
|
|
27 #include "system.h"
|
|
|
28 #include "coretypes.h"
|
|
|
29 #include "tm.h"
|
|
|
30 #include "rtl.h"
|
|
|
31 #include "obstack.h"
|
|
|
32 #include "hashtab.h"
|
|
|
33 #include "gensupport.h"
|
|
|
34
|
|
|
35 static htab_t md_constants;
|
|
|
36
|
|
|
37 /* One element in a singly-linked list of (integer, string) pairs. */
|
|
|
38 struct map_value {
|
|
|
39 struct map_value *next;
|
|
|
40 int number;
|
|
|
41 const char *string;
|
|
|
42 };
|
|
|
43
|
|
|
44 /* Maps an iterator or attribute name to a list of (integer, string) pairs.
|
|
|
45 The integers are mode or code values; the strings are either C conditions
|
|
|
46 or attribute values. */
|
|
|
47 struct mapping {
|
|
|
48 /* The name of the iterator or attribute. */
|
|
|
49 const char *name;
|
|
|
50
|
|
|
51 /* The group (modes or codes) to which the iterator or attribute belongs. */
|
|
|
52 struct iterator_group *group;
|
|
|
53
|
|
|
54 /* Gives a unique number to the attribute or iterator. Numbers are
|
|
|
55 allocated consecutively, starting at 0. */
|
|
|
56 int index;
|
|
|
57
|
|
|
58 /* The list of (integer, string) pairs. */
|
|
|
59 struct map_value *values;
|
|
|
60 };
|
|
|
61
|
|
|
62 /* A structure for abstracting the common parts of code and mode iterators. */
|
|
|
63 struct iterator_group {
|
|
|
64 /* Tables of "mapping" structures, one for attributes and one for iterators. */
|
|
|
65 htab_t attrs, iterators;
|
|
|
66
|
|
|
67 /* The number of "real" modes or codes (and by extension, the first
|
|
|
68 number available for use as an iterator placeholder). */
|
|
|
69 int num_builtins;
|
|
|
70
|
|
|
71 /* Treat the given string as the name of a standard mode or code and
|
|
|
72 return its integer value. Use the given file for error reporting. */
|
|
|
73 int (*find_builtin) (const char *, FILE *);
|
|
|
74
|
|
|
75 /* Return true if the given rtx uses the given mode or code. */
|
|
|
76 bool (*uses_iterator_p) (rtx, int);
|
|
|
77
|
|
|
78 /* Make the given rtx use the given mode or code. */
|
|
|
79 void (*apply_iterator) (rtx, int);
|
|
|
80 };
|
|
|
81
|
|
|
82 /* Associates PTR (which can be a string, etc.) with the file location
|
|
|
83 specified by FILENAME and LINENO. */
|
|
|
84 struct ptr_loc {
|
|
|
85 const void *ptr;
|
|
|
86 const char *filename;
|
|
|
87 int lineno;
|
|
|
88 };
|
|
|
89
|
|
|
90 /* A structure used to pass data from read_rtx to apply_iterator_traverse
|
|
|
91 via htab_traverse. */
|
|
|
92 struct iterator_traverse_data {
|
|
|
93 /* Instruction queue. */
|
|
|
94 rtx queue;
|
|
|
95 /* Attributes seen for modes. */
|
|
|
96 struct map_value *mode_maps;
|
|
|
97 /* Input file. */
|
|
|
98 FILE *infile;
|
|
|
99 /* The last unknown attribute used as a mode. */
|
|
|
100 const char *unknown_mode_attr;
|
|
|
101 };
|
|
|
102
|
|
|
103 /* If CODE is the number of a code iterator, return a real rtx code that
|
|
|
104 has the same format. Return CODE otherwise. */
|
|
|
105 #define BELLWETHER_CODE(CODE) \
|
|
|
106 ((CODE) < NUM_RTX_CODE ? CODE : bellwether_codes[CODE - NUM_RTX_CODE])
|
|
|
107
|
|
|
108 static void fatal_with_file_and_line (FILE *, const char *, ...)
|
|
|
109 ATTRIBUTE_PRINTF_2 ATTRIBUTE_NORETURN;
|
|
|
110 static void fatal_expected_char (FILE *, int, int) ATTRIBUTE_NORETURN;
|
|
|
111 static int find_mode (const char *, FILE *);
|
|
|
112 static bool uses_mode_iterator_p (rtx, int);
|
|
|
113 static void apply_mode_iterator (rtx, int);
|
|
|
114 static int find_code (const char *, FILE *);
|
|
|
115 static bool uses_code_iterator_p (rtx, int);
|
|
|
116 static void apply_code_iterator (rtx, int);
|
|
|
117 static const char *apply_iterator_to_string (const char *, struct mapping *, int);
|
|
|
118 static rtx apply_iterator_to_rtx (rtx, struct mapping *, int,
|
|
|
119 struct map_value *, FILE *, const char **);
|
|
|
120 static bool uses_iterator_p (rtx, struct mapping *);
|
|
|
121 static const char *add_condition_to_string (const char *, const char *);
|
|
|
122 static void add_condition_to_rtx (rtx, const char *);
|
|
|
123 static int apply_iterator_traverse (void **, void *);
|
|
|
124 static struct mapping *add_mapping (struct iterator_group *, htab_t t,
|
|
|
125 const char *, FILE *);
|
|
|
126 static struct map_value **add_map_value (struct map_value **,
|
|
|
127 int, const char *);
|
|
|
128 static void initialize_iterators (void);
|
|
|
129 static void read_name (char *, FILE *);
|
|
|
130 static hashval_t leading_ptr_hash (const void *);
|
|
|
131 static int leading_ptr_eq_p (const void *, const void *);
|
|
|
132 static void set_rtx_ptr_loc (const void *, const char *, int);
|
|
|
133 static const struct ptr_loc *get_rtx_ptr_loc (const void *);
|
|
|
134 static char *read_string (FILE *, int);
|
|
|
135 static char *read_quoted_string (FILE *);
|
|
|
136 static char *read_braced_string (FILE *);
|
|
|
137 static void read_escape (FILE *);
|
|
|
138 static hashval_t def_hash (const void *);
|
|
|
139 static int def_name_eq_p (const void *, const void *);
|
|
|
140 static void read_constants (FILE *infile, char *tmp_char);
|
|
|
141 static void read_conditions (FILE *infile, char *tmp_char);
|
|
|
142 static void validate_const_int (FILE *, const char *);
|
|
|
143 static int find_iterator (struct iterator_group *, const char *, FILE *);
|
|
|
144 static struct mapping *read_mapping (struct iterator_group *, htab_t, FILE *);
|
|
|
145 static void check_code_iterator (struct mapping *, FILE *);
|
|
|
146 static rtx read_rtx_1 (FILE *, struct map_value **);
|
|
|
147 static rtx read_rtx_variadic (FILE *, struct map_value **, rtx);
|
|
|
148
|
|
|
149 /* The mode and code iterator structures. */
|
|
|
150 static struct iterator_group modes, codes;
|
|
|
151
|
|
|
152 /* Index I is the value of BELLWETHER_CODE (I + NUM_RTX_CODE). */
|
|
|
153 static enum rtx_code *bellwether_codes;
|
|
|
154
|
|
|
155 /* Obstack used for allocating RTL strings. */
|
|
|
156 static struct obstack string_obstack;
|
|
|
157
|
|
|
158 /* A table of ptr_locs, hashed on the PTR field. */
|
|
|
159 static htab_t ptr_locs;
|
|
|
160
|
|
|
161 /* An obstack for the above. Plain xmalloc is a bit heavyweight for a
|
|
|
162 small structure like ptr_loc. */
|
|
|
163 static struct obstack ptr_loc_obstack;
|
|
|
164
|
|
|
165 /* A hash table of triples (A, B, C), where each of A, B and C is a condition
|
|
|
166 and A is equivalent to "B && C". This is used to keep track of the source
|
|
|
167 of conditions that are made up of separate rtx strings (such as the split
|
|
|
168 condition of a define_insn_and_split). */
|
|
|
169 static htab_t joined_conditions;
|
|
|
170
|
|
|
171 /* An obstack for allocating joined_conditions entries. */
|
|
|
172 static struct obstack joined_conditions_obstack;
|
|
|
173
|
|
|
174 /* Subroutines of read_rtx. */
|
|
|
175
|
|
|
176 /* The current line number for the file. */
|
|
|
177 int read_rtx_lineno = 1;
|
|
|
178
|
|
|
179 /* The filename for error reporting. */
|
|
|
180 const char *read_rtx_filename = "<unknown>";
|
|
|
181
|
|
|
182 static void
|
|
|
183 fatal_with_file_and_line (FILE *infile, const char *msg, ...)
|
|
|
184 {
|
|
|
185 char context[64];
|
|
|
186 size_t i;
|
|
|
187 int c;
|
|
|
188 va_list ap;
|
|
|
189
|
|
|
190 va_start (ap, msg);
|
|
|
191
|
|
|
192 fprintf (stderr, "%s:%d: ", read_rtx_filename, read_rtx_lineno);
|
|
|
193 vfprintf (stderr, msg, ap);
|
|
|
194 putc ('\n', stderr);
|
|
|
195
|
|
|
196 /* Gather some following context. */
|
|
|
197 for (i = 0; i < sizeof (context)-1; ++i)
|
|
|
198 {
|
|
|
199 c = getc (infile);
|
|
|
200 if (c == EOF)
|
|
|
201 break;
|
|
|
202 if (c == '\r' || c == '\n')
|
|
|
203 break;
|
|
|
204 context[i] = c;
|
|
|
205 }
|
|
|
206 context[i] = '\0';
|
|
|
207
|
|
|
208 fprintf (stderr, "%s:%d: following context is `%s'\n",
|
|
|
209 read_rtx_filename, read_rtx_lineno, context);
|
|
|
210
|
|
|
211 va_end (ap);
|
|
|
212 exit (1);
|
|
|
213 }
|
|
|
214
|
|
|
215 /* Dump code after printing a message. Used when read_rtx finds
|
|
|
216 invalid data. */
|
|
|
217
|
|
|
218 static void
|
|
|
219 fatal_expected_char (FILE *infile, int expected_c, int actual_c)
|
|
|
220 {
|
|
|
221 if (actual_c == EOF)
|
|
|
222 fatal_with_file_and_line (infile, "expected character `%c', found EOF",
|
|
|
223 expected_c);
|
|
|
224 else
|
|
|
225 fatal_with_file_and_line (infile, "expected character `%c', found `%c'",
|
|
|
226 expected_c, actual_c);
|
|
|
227 }
|
|
|
228
|
|
|
229 /* Implementations of the iterator_group callbacks for modes. */
|
|
|
230
|
|
|
231 static int
|
|
|
232 find_mode (const char *name, FILE *infile)
|
|
|
233 {
|
|
|
234 int i;
|
|
|
235
|
|
|
236 for (i = 0; i < NUM_MACHINE_MODES; i++)
|
|
|
237 if (strcmp (GET_MODE_NAME (i), name) == 0)
|
|
|
238 return i;
|
|
|
239
|
|
|
240 fatal_with_file_and_line (infile, "unknown mode `%s'", name);
|
|
|
241 }
|
|
|
242
|
|
|
243 static bool
|
|
|
244 uses_mode_iterator_p (rtx x, int mode)
|
|
|
245 {
|
|
|
246 return (int) GET_MODE (x) == mode;
|
|
|
247 }
|
|
|
248
|
|
|
249 static void
|
|
|
250 apply_mode_iterator (rtx x, int mode)
|
|
|
251 {
|
|
|
252 PUT_MODE (x, (enum machine_mode) mode);
|
|
|
253 }
|
|
|
254
|
|
|
255 /* Implementations of the iterator_group callbacks for codes. */
|
|
|
256
|
|
|
257 static int
|
|
|
258 find_code (const char *name, FILE *infile)
|
|
|
259 {
|
|
|
260 int i;
|
|
|
261
|
|
|
262 for (i = 0; i < NUM_RTX_CODE; i++)
|
|
|
263 if (strcmp (GET_RTX_NAME (i), name) == 0)
|
|
|
264 return i;
|
|
|
265
|
|
|
266 fatal_with_file_and_line (infile, "unknown rtx code `%s'", name);
|
|
|
267 }
|
|
|
268
|
|
|
269 static bool
|
|
|
270 uses_code_iterator_p (rtx x, int code)
|
|
|
271 {
|
|
|
272 return (int) GET_CODE (x) == code;
|
|
|
273 }
|
|
|
274
|
|
|
275 static void
|
|
|
276 apply_code_iterator (rtx x, int code)
|
|
|
277 {
|
|
|
278 PUT_CODE (x, (enum rtx_code) code);
|
|
|
279 }
|
|
|
280
|
|
|
281 /* Map a code or mode attribute string P to the underlying string for
|
|
|
282 ITERATOR and VALUE. */
|
|
|
283
|
|
|
284 static struct map_value *
|
|
|
285 map_attr_string (const char *p, struct mapping *iterator, int value)
|
|
|
286 {
|
|
|
287 const char *attr;
|
|
|
288 struct mapping *m;
|
|
|
289 struct map_value *v;
|
|
|
290
|
|
|
291 /* If there's a "iterator:" prefix, check whether the iterator name matches.
|
|
|
292 Set ATTR to the start of the attribute name. */
|
|
|
293 attr = strchr (p, ':');
|
|
|
294 if (attr == 0)
|
|
|
295 attr = p;
|
|
|
296 else
|
|
|
297 {
|
|
|
298 if (strncmp (p, iterator->name, attr - p) != 0
|
|
|
299 || iterator->name[attr - p] != 0)
|
|
|
300 return 0;
|
|
|
301 attr++;
|
|
|
302 }
|
|
|
303
|
|
|
304 /* Find the attribute specification. */
|
|
|
305 m = (struct mapping *) htab_find (iterator->group->attrs, &attr);
|
|
|
306 if (m == 0)
|
|
|
307 return 0;
|
|
|
308
|
|
|
309 /* Find the attribute value for VALUE. */
|
|
|
310 for (v = m->values; v != 0; v = v->next)
|
|
|
311 if (v->number == value)
|
|
|
312 break;
|
|
|
313
|
|
|
314 return v;
|
|
|
315 }
|
|
|
316
|
|
|
317 /* Given an attribute string used as a machine mode, return an index
|
|
|
318 to store in the machine mode to be translated by
|
|
|
319 apply_iterator_to_rtx. */
|
|
|
320
|
|
|
321 static unsigned int
|
|
|
322 mode_attr_index (struct map_value **mode_maps, const char *string)
|
|
|
323 {
|
|
|
324 char *p;
|
|
|
325 struct map_value *mv;
|
|
|
326
|
|
|
327 /* Copy the attribute string into permanent storage, without the
|
|
|
328 angle brackets around it. */
|
|
|
329 obstack_grow0 (&string_obstack, string + 1, strlen (string) - 2);
|
|
|
330 p = XOBFINISH (&string_obstack, char *);
|
|
|
331
|
|
|
332 mv = XNEW (struct map_value);
|
|
|
333 mv->number = *mode_maps == 0 ? 0 : (*mode_maps)->number + 1;
|
|
|
334 mv->string = p;
|
|
|
335 mv->next = *mode_maps;
|
|
|
336 *mode_maps = mv;
|
|
|
337
|
|
|
338 /* We return a code which we can map back into this string: the
|
|
|
339 number of machine modes + the number of mode iterators + the index
|
|
|
340 we just used. */
|
|
|
341 return MAX_MACHINE_MODE + htab_elements (modes.iterators) + mv->number;
|
|
|
342 }
|
|
|
343
|
|
|
344 /* Apply MODE_MAPS to the top level of X, expanding cases where an
|
|
|
345 attribute is used for a mode. ITERATOR is the current iterator we are
|
|
|
346 expanding, and VALUE is the value to which we are expanding it.
|
|
|
347 INFILE is used for error messages. This sets *UNKNOWN to true if
|
|
|
348 we find a mode attribute which has not yet been defined, and does
|
|
|
349 not change it otherwise. */
|
|
|
350
|
|
|
351 static void
|
|
|
352 apply_mode_maps (rtx x, struct map_value *mode_maps, struct mapping *iterator,
|
|
|
353 int value, FILE *infile, const char **unknown)
|
|
|
354 {
|
|
|
355 unsigned int offset;
|
|
|
356 int indx;
|
|
|
357 struct map_value *pm;
|
|
|
358
|
|
|
359 offset = MAX_MACHINE_MODE + htab_elements (modes.iterators);
|
|
|
360 if (GET_MODE (x) < offset)
|
|
|
361 return;
|
|
|
362
|
|
|
363 indx = GET_MODE (x) - offset;
|
|
|
364 for (pm = mode_maps; pm; pm = pm->next)
|
|
|
365 {
|
|
|
366 if (pm->number == indx)
|
|
|
367 {
|
|
|
368 struct map_value *v;
|
|
|
369
|
|
|
370 v = map_attr_string (pm->string, iterator, value);
|
|
|
371 if (v)
|
|
|
372 PUT_MODE (x, (enum machine_mode) find_mode (v->string, infile));
|
|
|
373 else
|
|
|
374 *unknown = pm->string;
|
|
|
375 return;
|
|
|
376 }
|
|
|
377 }
|
|
|
378 }
|
|
|
379
|
|
|
380 /* Given that ITERATOR is being expanded as VALUE, apply the appropriate
|
|
|
381 string substitutions to STRING. Return the new string if any changes
|
|
|
382 were needed, otherwise return STRING itself. */
|
|
|
383
|
|
|
384 static const char *
|
|
|
385 apply_iterator_to_string (const char *string, struct mapping *iterator, int value)
|
|
|
386 {
|
|
|
387 char *base, *copy, *p, *start, *end;
|
|
|
388 struct map_value *v;
|
|
|
389
|
|
|
390 if (string == 0)
|
|
|
391 return string;
|
|
|
392
|
|
|
393 base = p = copy = ASTRDUP (string);
|
|
|
394 while ((start = strchr (p, '<')) && (end = strchr (start, '>')))
|
|
|
395 {
|
|
|
396 p = start + 1;
|
|
|
397
|
|
|
398 *end = 0;
|
|
|
399 v = map_attr_string (p, iterator, value);
|
|
|
400 *end = '>';
|
|
|
401 if (v == 0)
|
|
|
402 continue;
|
|
|
403
|
|
|
404 /* Add everything between the last copied byte and the '<',
|
|
|
405 then add in the attribute value. */
|
|
|
406 obstack_grow (&string_obstack, base, start - base);
|
|
|
407 obstack_grow (&string_obstack, v->string, strlen (v->string));
|
|
|
408 base = end + 1;
|
|
|
409 }
|
|
|
410 if (base != copy)
|
|
|
411 {
|
|
|
412 obstack_grow (&string_obstack, base, strlen (base) + 1);
|
|
|
413 copy = XOBFINISH (&string_obstack, char *);
|
|
|
414 copy_rtx_ptr_loc (copy, string);
|
|
|
415 return copy;
|
|
|
416 }
|
|
|
417 return string;
|
|
|
418 }
|
|
|
419
|
|
|
420 /* Return a copy of ORIGINAL in which all uses of ITERATOR have been
|
|
|
421 replaced by VALUE. MODE_MAPS holds information about attribute
|
|
|
422 strings used for modes. INFILE is used for error messages. This
|
|
|
423 sets *UNKNOWN_MODE_ATTR to the value of an unknown mode attribute,
|
|
|
424 and does not change it otherwise. */
|
|
|
425
|
|
|
426 static rtx
|
|
|
427 apply_iterator_to_rtx (rtx original, struct mapping *iterator, int value,
|
|
|
428 struct map_value *mode_maps, FILE *infile,
|
|
|
429 const char **unknown_mode_attr)
|
|
|
430 {
|
|
|
431 struct iterator_group *group;
|
|
|
432 const char *format_ptr;
|
|
|
433 int i, j;
|
|
|
434 rtx x;
|
|
|
435 enum rtx_code bellwether_code;
|
|
|
436
|
|
|
437 if (original == 0)
|
|
|
438 return original;
|
|
|
439
|
|
|
440 /* Create a shallow copy of ORIGINAL. */
|
|
|
441 bellwether_code = BELLWETHER_CODE (GET_CODE (original));
|
|
|
442 x = rtx_alloc (bellwether_code);
|
|
|
443 memcpy (x, original, RTX_CODE_SIZE (bellwether_code));
|
|
|
444
|
|
|
445 /* Change the mode or code itself. */
|
|
|
446 group = iterator->group;
|
|
|
447 if (group->uses_iterator_p (x, iterator->index + group->num_builtins))
|
|
|
448 group->apply_iterator (x, value);
|
|
|
449
|
|
|
450 if (mode_maps)
|
|
|
451 apply_mode_maps (x, mode_maps, iterator, value, infile, unknown_mode_attr);
|
|
|
452
|
|
|
453 /* Change each string and recursively change each rtx. */
|
|
|
454 format_ptr = GET_RTX_FORMAT (bellwether_code);
|
|
|
455 for (i = 0; format_ptr[i] != 0; i++)
|
|
|
456 switch (format_ptr[i])
|
|
|
457 {
|
|
|
458 case 'T':
|
|
|
459 XTMPL (x, i) = apply_iterator_to_string (XTMPL (x, i), iterator, value);
|
|
|
460 break;
|
|
|
461
|
|
|
462 case 'S':
|
|
|
463 case 's':
|
|
|
464 XSTR (x, i) = apply_iterator_to_string (XSTR (x, i), iterator, value);
|
|
|
465 break;
|
|
|
466
|
|
|
467 case 'e':
|
|
|
468 XEXP (x, i) = apply_iterator_to_rtx (XEXP (x, i), iterator, value,
|
|
|
469 mode_maps, infile,
|
|
|
470 unknown_mode_attr);
|
|
|
471 break;
|
|
|
472
|
|
|
473 case 'V':
|
|
|
474 case 'E':
|
|
|
475 if (XVEC (original, i))
|
|
|
476 {
|
|
|
477 XVEC (x, i) = rtvec_alloc (XVECLEN (original, i));
|
|
|
478 for (j = 0; j < XVECLEN (x, i); j++)
|
|
|
479 XVECEXP (x, i, j) = apply_iterator_to_rtx (XVECEXP (original, i, j),
|
|
|
480 iterator, value, mode_maps,
|
|
|
481 infile,
|
|
|
482 unknown_mode_attr);
|
|
|
483 }
|
|
|
484 break;
|
|
|
485
|
|
|
486 default:
|
|
|
487 break;
|
|
|
488 }
|
|
|
489 return x;
|
|
|
490 }
|
|
|
491
|
|
|
492 /* Return true if X (or some subexpression of X) uses iterator ITERATOR. */
|
|
|
493
|
|
|
494 static bool
|
|
|
495 uses_iterator_p (rtx x, struct mapping *iterator)
|
|
|
496 {
|
|
|
497 struct iterator_group *group;
|
|
|
498 const char *format_ptr;
|
|
|
499 int i, j;
|
|
|
500
|
|
|
501 if (x == 0)
|
|
|
502 return false;
|
|
|
503
|
|
|
504 group = iterator->group;
|
|
|
505 if (group->uses_iterator_p (x, iterator->index + group->num_builtins))
|
|
|
506 return true;
|
|
|
507
|
|
|
508 format_ptr = GET_RTX_FORMAT (BELLWETHER_CODE (GET_CODE (x)));
|
|
|
509 for (i = 0; format_ptr[i] != 0; i++)
|
|
|
510 switch (format_ptr[i])
|
|
|
511 {
|
|
|
512 case 'e':
|
|
|
513 if (uses_iterator_p (XEXP (x, i), iterator))
|
|
|
514 return true;
|
|
|
515 break;
|
|
|
516
|
|
|
517 case 'V':
|
|
|
518 case 'E':
|
|
|
519 if (XVEC (x, i))
|
|
|
520 for (j = 0; j < XVECLEN (x, i); j++)
|
|
|
521 if (uses_iterator_p (XVECEXP (x, i, j), iterator))
|
|
|
522 return true;
|
|
|
523 break;
|
|
|
524
|
|
|
525 default:
|
|
|
526 break;
|
|
|
527 }
|
|
|
528 return false;
|
|
|
529 }
|
|
|
530
|
|
|
531 /* Return a condition that must satisfy both ORIGINAL and EXTRA. If ORIGINAL
|
|
|
532 has the form "&& ..." (as used in define_insn_and_splits), assume that
|
|
|
533 EXTRA is already satisfied. Empty strings are treated like "true". */
|
|
|
534
|
|
|
535 static const char *
|
|
|
536 add_condition_to_string (const char *original, const char *extra)
|
|
|
537 {
|
|
|
538 if (original != 0 && original[0] == '&' && original[1] == '&')
|
|
|
539 return original;
|
|
|
540 return join_c_conditions (original, extra);
|
|
|
541 }
|
|
|
542
|
|
|
543 /* Like add_condition, but applied to all conditions in rtx X. */
|
|
|
544
|
|
|
545 static void
|
|
|
546 add_condition_to_rtx (rtx x, const char *extra)
|
|
|
547 {
|
|
|
548 switch (GET_CODE (x))
|
|
|
549 {
|
|
|
550 case DEFINE_INSN:
|
|
|
551 case DEFINE_EXPAND:
|
|
|
552 XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra);
|
|
|
553 break;
|
|
|
554
|
|
|
555 case DEFINE_SPLIT:
|
|
|
556 case DEFINE_PEEPHOLE:
|
|
|
557 case DEFINE_PEEPHOLE2:
|
|
|
558 case DEFINE_COND_EXEC:
|
|
|
559 XSTR (x, 1) = add_condition_to_string (XSTR (x, 1), extra);
|
|
|
560 break;
|
|
|
561
|
|
|
562 case DEFINE_INSN_AND_SPLIT:
|
|
|
563 XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra);
|
|
|
564 XSTR (x, 4) = add_condition_to_string (XSTR (x, 4), extra);
|
|
|
565 break;
|
|
|
566
|
|
|
567 default:
|
|
|
568 break;
|
|
|
569 }
|
|
|
570 }
|
|
|
571
|
|
|
572 /* A htab_traverse callback. Search the EXPR_LIST given by DATA
|
|
|
573 for rtxes that use the iterator in *SLOT. Replace each such rtx
|
|
|
574 with a list of expansions. */
|
|
|
575
|
|
|
576 static int
|
|
|
577 apply_iterator_traverse (void **slot, void *data)
|
|
|
578 {
|
|
|
579 struct iterator_traverse_data *mtd = (struct iterator_traverse_data *) data;
|
|
|
580 struct mapping *iterator;
|
|
|
581 struct map_value *v;
|
|
|
582 rtx elem, new_elem, original, x;
|
|
|
583
|
|
|
584 iterator = (struct mapping *) *slot;
|
|
|
585 for (elem = mtd->queue; elem != 0; elem = XEXP (elem, 1))
|
|
|
586 if (uses_iterator_p (XEXP (elem, 0), iterator))
|
|
|
587 {
|
|
|
588 /* For each iterator we expand, we set UNKNOWN_MODE_ATTR to NULL.
|
|
|
589 If apply_iterator_rtx finds an unknown attribute for a mode,
|
|
|
590 it will set it to the attribute. We want to know whether
|
|
|
591 the attribute is unknown after we have expanded all
|
|
|
592 possible iterators, so setting it to NULL here gives us the
|
|
|
593 right result when the hash table traversal is complete. */
|
|
|
594 mtd->unknown_mode_attr = NULL;
|
|
|
595
|
|
|
596 original = XEXP (elem, 0);
|
|
|
597 for (v = iterator->values; v != 0; v = v->next)
|
|
|
598 {
|
|
|
599 x = apply_iterator_to_rtx (original, iterator, v->number,
|
|
|
600 mtd->mode_maps, mtd->infile,
|
|
|
601 &mtd->unknown_mode_attr);
|
|
|
602 add_condition_to_rtx (x, v->string);
|
|
|
603 if (v != iterator->values)
|
|
|
604 {
|
|
|
605 /* Insert a new EXPR_LIST node after ELEM and put the
|
|
|
606 new expansion there. */
|
|
|
607 new_elem = rtx_alloc (EXPR_LIST);
|
|
|
608 XEXP (new_elem, 1) = XEXP (elem, 1);
|
|
|
609 XEXP (elem, 1) = new_elem;
|
|
|
610 elem = new_elem;
|
|
|
611 }
|
|
|
612 XEXP (elem, 0) = x;
|
|
|
613 }
|
|
|
614 }
|
|
|
615 return 1;
|
|
|
616 }
|
|
|
617
|
|
|
618 /* Add a new "mapping" structure to hashtable TABLE. NAME is the name
|
|
|
619 of the mapping, GROUP is the group to which it belongs, and INFILE
|
|
|
620 is the file that defined the mapping. */
|
|
|
621
|
|
|
622 static struct mapping *
|
|
|
623 add_mapping (struct iterator_group *group, htab_t table,
|
|
|
624 const char *name, FILE *infile)
|
|
|
625 {
|
|
|
626 struct mapping *m;
|
|
|
627 void **slot;
|
|
|
628
|
|
|
629 m = XNEW (struct mapping);
|
|
|
630 m->name = xstrdup (name);
|
|
|
631 m->group = group;
|
|
|
632 m->index = htab_elements (table);
|
|
|
633 m->values = 0;
|
|
|
634
|
|
|
635 slot = htab_find_slot (table, m, INSERT);
|
|
|
636 if (*slot != 0)
|
|
|
637 fatal_with_file_and_line (infile, "`%s' already defined", name);
|
|
|
638
|
|
|
639 *slot = m;
|
|
|
640 return m;
|
|
|
641 }
|
|
|
642
|
|
|
643 /* Add the pair (NUMBER, STRING) to a list of map_value structures.
|
|
|
644 END_PTR points to the current null terminator for the list; return
|
|
|
645 a pointer the new null terminator. */
|
|
|
646
|
|
|
647 static struct map_value **
|
|
|
648 add_map_value (struct map_value **end_ptr, int number, const char *string)
|
|
|
649 {
|
|
|
650 struct map_value *value;
|
|
|
651
|
|
|
652 value = XNEW (struct map_value);
|
|
|
653 value->next = 0;
|
|
|
654 value->number = number;
|
|
|
655 value->string = string;
|
|
|
656
|
|
|
657 *end_ptr = value;
|
|
|
658 return &value->next;
|
|
|
659 }
|
|
|
660
|
|
|
661 /* Do one-time initialization of the mode and code attributes. */
|
|
|
662
|
|
|
663 static void
|
|
|
664 initialize_iterators (void)
|
|
|
665 {
|
|
|
666 struct mapping *lower, *upper;
|
|
|
667 struct map_value **lower_ptr, **upper_ptr;
|
|
|
668 char *copy, *p;
|
|
|
669 int i;
|
|
|
670
|
|
|
671 modes.attrs = htab_create (13, def_hash, def_name_eq_p, 0);
|
|
|
672 modes.iterators = htab_create (13, def_hash, def_name_eq_p, 0);
|
|
|
673 modes.num_builtins = MAX_MACHINE_MODE;
|
|
|
674 modes.find_builtin = find_mode;
|
|
|
675 modes.uses_iterator_p = uses_mode_iterator_p;
|
|
|
676 modes.apply_iterator = apply_mode_iterator;
|
|
|
677
|
|
|
678 codes.attrs = htab_create (13, def_hash, def_name_eq_p, 0);
|
|
|
679 codes.iterators = htab_create (13, def_hash, def_name_eq_p, 0);
|
|
|
680 codes.num_builtins = NUM_RTX_CODE;
|
|
|
681 codes.find_builtin = find_code;
|
|
|
682 codes.uses_iterator_p = uses_code_iterator_p;
|
|
|
683 codes.apply_iterator = apply_code_iterator;
|
|
|
684
|
|
|
685 lower = add_mapping (&modes, modes.attrs, "mode", 0);
|
|
|
686 upper = add_mapping (&modes, modes.attrs, "MODE", 0);
|
|
|
687 lower_ptr = &lower->values;
|
|
|
688 upper_ptr = &upper->values;
|
|
|
689 for (i = 0; i < MAX_MACHINE_MODE; i++)
|
|
|
690 {
|
|
|
691 copy = xstrdup (GET_MODE_NAME (i));
|
|
|
692 for (p = copy; *p != 0; p++)
|
|
|
693 *p = TOLOWER (*p);
|
|
|
694
|
|
|
695 upper_ptr = add_map_value (upper_ptr, i, GET_MODE_NAME (i));
|
|
|
696 lower_ptr = add_map_value (lower_ptr, i, copy);
|
|
|
697 }
|
|
|
698
|
|
|
699 lower = add_mapping (&codes, codes.attrs, "code", 0);
|
|
|
700 upper = add_mapping (&codes, codes.attrs, "CODE", 0);
|
|
|
701 lower_ptr = &lower->values;
|
|
|
702 upper_ptr = &upper->values;
|
|
|
703 for (i = 0; i < NUM_RTX_CODE; i++)
|
|
|
704 {
|
|
|
705 copy = xstrdup (GET_RTX_NAME (i));
|
|
|
706 for (p = copy; *p != 0; p++)
|
|
|
707 *p = TOUPPER (*p);
|
|
|
708
|
|
|
709 lower_ptr = add_map_value (lower_ptr, i, GET_RTX_NAME (i));
|
|
|
710 upper_ptr = add_map_value (upper_ptr, i, copy);
|
|
|
711 }
|
|
|
712 }
|
|
|
713
|
|
|
714 /* Return a hash value for the pointer pointed to by DEF. */
|
|
|
715
|
|
|
716 static hashval_t
|
|
|
717 leading_ptr_hash (const void *def)
|
|
|
718 {
|
|
|
719 return htab_hash_pointer (*(const void *const *) def);
|
|
|
720 }
|
|
|
721
|
|
|
722 /* Return true if DEF1 and DEF2 are pointers to the same pointer. */
|
|
|
723
|
|
|
724 static int
|
|
|
725 leading_ptr_eq_p (const void *def1, const void *def2)
|
|
|
726 {
|
|
|
727 return *(const void *const *) def1 == *(const void *const *) def2;
|
|
|
728 }
|
|
|
729
|
|
|
730 /* Associate PTR with the file position given by FILENAME and LINENO. */
|
|
|
731
|
|
|
732 static void
|
|
|
733 set_rtx_ptr_loc (const void *ptr, const char *filename, int lineno)
|
|
|
734 {
|
|
|
735 struct ptr_loc *loc;
|
|
|
736
|
|
|
737 loc = (struct ptr_loc *) obstack_alloc (&ptr_loc_obstack,
|
|
|
738 sizeof (struct ptr_loc));
|
|
|
739 loc->ptr = ptr;
|
|
|
740 loc->filename = filename;
|
|
|
741 loc->lineno = lineno;
|
|
|
742 *htab_find_slot (ptr_locs, loc, INSERT) = loc;
|
|
|
743 }
|
|
|
744
|
|
|
745 /* Return the position associated with pointer PTR. Return null if no
|
|
|
746 position was set. */
|
|
|
747
|
|
|
748 static const struct ptr_loc *
|
|
|
749 get_rtx_ptr_loc (const void *ptr)
|
|
|
750 {
|
|
|
751 return (const struct ptr_loc *) htab_find (ptr_locs, &ptr);
|
|
|
752 }
|
|
|
753
|
|
|
754 /* Associate NEW_PTR with the same file position as OLD_PTR. */
|
|
|
755
|
|
|
756 void
|
|
|
757 copy_rtx_ptr_loc (const void *new_ptr, const void *old_ptr)
|
|
|
758 {
|
|
|
759 const struct ptr_loc *loc = get_rtx_ptr_loc (old_ptr);
|
|
|
760 if (loc != 0)
|
|
|
761 set_rtx_ptr_loc (new_ptr, loc->filename, loc->lineno);
|
|
|
762 }
|
|
|
763
|
|
|
764 /* If PTR is associated with a known file position, print a #line
|
|
|
765 directive for it. */
|
|
|
766
|
|
|
767 void
|
|
|
768 print_rtx_ptr_loc (const void *ptr)
|
|
|
769 {
|
|
|
770 const struct ptr_loc *loc = get_rtx_ptr_loc (ptr);
|
|
|
771 if (loc != 0)
|
|
|
772 printf ("#line %d \"%s\"\n", loc->lineno, loc->filename);
|
|
|
773 }
|
|
|
774
|
|
|
775 /* Return a condition that satisfies both COND1 and COND2. Either string
|
|
|
776 may be null or empty. */
|
|
|
777
|
|
|
778 const char *
|
|
|
779 join_c_conditions (const char *cond1, const char *cond2)
|
|
|
780 {
|
|
|
781 char *result;
|
|
|
782 const void **entry;
|
|
|
783
|
|
|
784 if (cond1 == 0 || cond1[0] == 0)
|
|
|
785 return cond2;
|
|
|
786
|
|
|
787 if (cond2 == 0 || cond2[0] == 0)
|
|
|
788 return cond1;
|
|
|
789
|
|
|
790 if (strcmp (cond1, cond2) == 0)
|
|
|
791 return cond1;
|
|
|
792
|
|
|
793 result = concat ("(", cond1, ") && (", cond2, ")", NULL);
|
|
|
794 obstack_ptr_grow (&joined_conditions_obstack, result);
|
|
|
795 obstack_ptr_grow (&joined_conditions_obstack, cond1);
|
|
|
796 obstack_ptr_grow (&joined_conditions_obstack, cond2);
|
|
|
797 entry = XOBFINISH (&joined_conditions_obstack, const void **);
|
|
|
798 *htab_find_slot (joined_conditions, entry, INSERT) = entry;
|
|
|
799 return result;
|
|
|
800 }
|
|
|
801
|
|
|
802 /* Print condition COND, wrapped in brackets. If COND was created by
|
|
|
803 join_c_conditions, recursively invoke this function for the original
|
|
|
804 conditions and join the result with "&&". Otherwise print a #line
|
|
|
805 directive for COND if its original file position is known. */
|
|
|
806
|
|
|
807 void
|
|
|
808 print_c_condition (const char *cond)
|
|
|
809 {
|
|
|
810 const char **halves = (const char **) htab_find (joined_conditions, &cond);
|
|
|
811 if (halves != 0)
|
|
|
812 {
|
|
|
813 printf ("(");
|
|
|
814 print_c_condition (halves[1]);
|
|
|
815 printf (" && ");
|
|
|
816 print_c_condition (halves[2]);
|
|
|
817 printf (")");
|
|
|
818 }
|
|
|
819 else
|
|
|
820 {
|
|
|
821 putc ('\n', stdout);
|
|
|
822 print_rtx_ptr_loc (cond);
|
|
|
823 printf ("(%s)", cond);
|
|
|
824 }
|
|
|
825 }
|
|
|
826
|
|
|
827 /* Read chars from INFILE until a non-whitespace char
|
|
|
828 and return that. Comments, both Lisp style and C style,
|
|
|
829 are treated as whitespace.
|
|
|
830 Tools such as genflags use this function. */
|
|
|
831
|
|
|
832 int
|
|
|
833 read_skip_spaces (FILE *infile)
|
|
|
834 {
|
|
|
835 int c;
|
|
|
836
|
|
|
837 while (1)
|
|
|
838 {
|
|
|
839 c = getc (infile);
|
|
|
840 switch (c)
|
|
|
841 {
|
|
|
842 case '\n':
|
|
|
843 read_rtx_lineno++;
|
|
|
844 break;
|
|
|
845
|
|
|
846 case ' ': case '\t': case '\f': case '\r':
|
|
|
847 break;
|
|
|
848
|
|
|
849 case ';':
|
|
|
850 do
|
|
|
851 c = getc (infile);
|
|
|
852 while (c != '\n' && c != EOF);
|
|
|
853 read_rtx_lineno++;
|
|
|
854 break;
|
|
|
855
|
|
|
856 case '/':
|
|
|
857 {
|
|
|
858 int prevc;
|
|
|
859 c = getc (infile);
|
|
|
860 if (c != '*')
|
|
|
861 fatal_expected_char (infile, '*', c);
|
|
|
862
|
|
|
863 prevc = 0;
|
|
|
864 while ((c = getc (infile)) && c != EOF)
|
|
|
865 {
|
|
|
866 if (c == '\n')
|
|
|
867 read_rtx_lineno++;
|
|
|
868 else if (prevc == '*' && c == '/')
|
|
|
869 break;
|
|
|
870 prevc = c;
|
|
|
871 }
|
|
|
872 }
|
|
|
873 break;
|
|
|
874
|
|
|
875 default:
|
|
|
876 return c;
|
|
|
877 }
|
|
|
878 }
|
|
|
879 }
|
|
|
880
|
|
|
881 /* Read an rtx code name into the buffer STR[].
|
|
|
882 It is terminated by any of the punctuation chars of rtx printed syntax. */
|
|
|
883
|
|
|
884 static void
|
|
|
885 read_name (char *str, FILE *infile)
|
|
|
886 {
|
|
|
887 char *p;
|
|
|
888 int c;
|
|
|
889
|
|
|
890 c = read_skip_spaces (infile);
|
|
|
891
|
|
|
892 p = str;
|
|
|
893 while (1)
|
|
|
894 {
|
|
|
895 if (c == ' ' || c == '\n' || c == '\t' || c == '\f' || c == '\r' || c == EOF)
|
|
|
896 break;
|
|
|
897 if (c == ':' || c == ')' || c == ']' || c == '"' || c == '/'
|
|
|
898 || c == '(' || c == '[')
|
|
|
899 {
|
|
|
900 ungetc (c, infile);
|
|
|
901 break;
|
|
|
902 }
|
|
|
903 *p++ = c;
|
|
|
904 c = getc (infile);
|
|
|
905 }
|
|
|
906 if (p == str)
|
|
|
907 fatal_with_file_and_line (infile, "missing name or number");
|
|
|
908 if (c == '\n')
|
|
|
909 read_rtx_lineno++;
|
|
|
910
|
|
|
911 *p = 0;
|
|
|
912
|
|
|
913 if (md_constants)
|
|
|
914 {
|
|
|
915 /* Do constant expansion. */
|
|
|
916 struct md_constant *def;
|
|
|
917
|
|
|
918 p = str;
|
|
|
919 do
|
|
|
920 {
|
|
|
921 struct md_constant tmp_def;
|
|
|
922
|
|
|
923 tmp_def.name = p;
|
|
|
924 def = (struct md_constant *) htab_find (md_constants, &tmp_def);
|
|
|
925 if (def)
|
|
|
926 p = def->value;
|
|
|
927 } while (def);
|
|
|
928 if (p != str)
|
|
|
929 strcpy (str, p);
|
|
|
930 }
|
|
|
931 }
|
|
|
932
|
|
|
933 /* Subroutine of the string readers. Handles backslash escapes.
|
|
|
934 Caller has read the backslash, but not placed it into the obstack. */
|
|
|
935 static void
|
|
|
936 read_escape (FILE *infile)
|
|
|
937 {
|
|
|
938 int c = getc (infile);
|
|
|
939
|
|
|
940 switch (c)
|
|
|
941 {
|
|
|
942 /* Backslash-newline is replaced by nothing, as in C. */
|
|
|
943 case '\n':
|
|
|
944 read_rtx_lineno++;
|
|
|
945 return;
|
|
|
946
|
|
|
947 /* \" \' \\ are replaced by the second character. */
|
|
|
948 case '\\':
|
|
|
949 case '"':
|
|
|
950 case '\'':
|
|
|
951 break;
|
|
|
952
|
|
|
953 /* Standard C string escapes:
|
|
|
954 \a \b \f \n \r \t \v
|
|
|
955 \[0-7] \x
|
|
|
956 all are passed through to the output string unmolested.
|
|
|
957 In normal use these wind up in a string constant processed
|
|
|
958 by the C compiler, which will translate them appropriately.
|
|
|
959 We do not bother checking that \[0-7] are followed by up to
|
|
|
960 two octal digits, or that \x is followed by N hex digits.
|
|
|
961 \? \u \U are left out because they are not in traditional C. */
|
|
|
962 case 'a': case 'b': case 'f': case 'n': case 'r': case 't': case 'v':
|
|
|
963 case '0': case '1': case '2': case '3': case '4': case '5': case '6':
|
|
|
964 case '7': case 'x':
|
|
|
965 obstack_1grow (&string_obstack, '\\');
|
|
|
966 break;
|
|
|
967
|
|
|
968 /* \; makes stuff for a C string constant containing
|
|
|
969 newline and tab. */
|
|
|
970 case ';':
|
|
|
971 obstack_grow (&string_obstack, "\\n\\t", 4);
|
|
|
972 return;
|
|
|
973
|
|
|
974 /* pass anything else through, but issue a warning. */
|
|
|
975 default:
|
|
|
976 fprintf (stderr, "%s:%d: warning: unrecognized escape \\%c\n",
|
|
|
977 read_rtx_filename, read_rtx_lineno, c);
|
|
|
978 obstack_1grow (&string_obstack, '\\');
|
|
|
979 break;
|
|
|
980 }
|
|
|
981
|
|
|
982 obstack_1grow (&string_obstack, c);
|
|
|
983 }
|
|
|
984
|
|
|
985
|
|
|
986 /* Read a double-quoted string onto the obstack. Caller has scanned
|
|
|
987 the leading quote. */
|
|
|
988 static char *
|
|
|
989 read_quoted_string (FILE *infile)
|
|
|
990 {
|
|
|
991 int c;
|
|
|
992
|
|
|
993 while (1)
|
|
|
994 {
|
|
|
995 c = getc (infile); /* Read the string */
|
|
|
996 if (c == '\n')
|
|
|
997 read_rtx_lineno++;
|
|
|
998 else if (c == '\\')
|
|
|
999 {
|
|
|
1000 read_escape (infile);
|
|
|
1001 continue;
|
|
|
1002 }
|
|
|
1003 else if (c == '"' || c == EOF)
|
|
|
1004 break;
|
|
|
1005
|
|
|
1006 obstack_1grow (&string_obstack, c);
|
|
|
1007 }
|
|
|
1008
|
|
|
1009 obstack_1grow (&string_obstack, 0);
|
|
|
1010 return XOBFINISH (&string_obstack, char *);
|
|
|
1011 }
|
|
|
1012
|
|
|
1013 /* Read a braced string (a la Tcl) onto the string obstack. Caller
|
|
|
1014 has scanned the leading brace. Note that unlike quoted strings,
|
|
|
1015 the outermost braces _are_ included in the string constant. */
|
|
|
1016 static char *
|
|
|
1017 read_braced_string (FILE *infile)
|
|
|
1018 {
|
|
|
1019 int c;
|
|
|
1020 int brace_depth = 1; /* caller-processed */
|
|
|
1021 unsigned long starting_read_rtx_lineno = read_rtx_lineno;
|
|
|
1022
|
|
|
1023 obstack_1grow (&string_obstack, '{');
|
|
|
1024 while (brace_depth)
|
|
|
1025 {
|
|
|
1026 c = getc (infile); /* Read the string */
|
|
|
1027
|
|
|
1028 if (c == '\n')
|
|
|
1029 read_rtx_lineno++;
|
|
|
1030 else if (c == '{')
|
|
|
1031 brace_depth++;
|
|
|
1032 else if (c == '}')
|
|
|
1033 brace_depth--;
|
|
|
1034 else if (c == '\\')
|
|
|
1035 {
|
|
|
1036 read_escape (infile);
|
|
|
1037 continue;
|
|
|
1038 }
|
|
|
1039 else if (c == EOF)
|
|
|
1040 fatal_with_file_and_line
|
|
|
1041 (infile, "missing closing } for opening brace on line %lu",
|
|
|
1042 starting_read_rtx_lineno);
|
|
|
1043
|
|
|
1044 obstack_1grow (&string_obstack, c);
|
|
|
1045 }
|
|
|
1046
|
|
|
1047 obstack_1grow (&string_obstack, 0);
|
|
|
1048 return XOBFINISH (&string_obstack, char *);
|
|
|
1049 }
|
|
|
1050
|
|
|
1051 /* Read some kind of string constant. This is the high-level routine
|
|
|
1052 used by read_rtx. It handles surrounding parentheses, leading star,
|
|
|
1053 and dispatch to the appropriate string constant reader. */
|
|
|
1054
|
|
|
1055 static char *
|
|
|
1056 read_string (FILE *infile, int star_if_braced)
|
|
|
1057 {
|
|
|
1058 char *stringbuf;
|
|
|
1059 int saw_paren = 0;
|
|
|
1060 int c, old_lineno;
|
|
|
1061
|
|
|
1062 c = read_skip_spaces (infile);
|
|
|
1063 if (c == '(')
|
|
|
1064 {
|
|
|
1065 saw_paren = 1;
|
|
|
1066 c = read_skip_spaces (infile);
|
|
|
1067 }
|
|
|
1068
|
|
|
1069 old_lineno = read_rtx_lineno;
|
|
|
1070 if (c == '"')
|
|
|
1071 stringbuf = read_quoted_string (infile);
|
|
|
1072 else if (c == '{')
|
|
|
1073 {
|
|
|
1074 if (star_if_braced)
|
|
|
1075 obstack_1grow (&string_obstack, '*');
|
|
|
1076 stringbuf = read_braced_string (infile);
|
|
|
1077 }
|
|
|
1078 else
|
|
|
1079 fatal_with_file_and_line (infile, "expected `\"' or `{', found `%c'", c);
|
|
|
1080
|
|
|
1081 if (saw_paren)
|
|
|
1082 {
|
|
|
1083 c = read_skip_spaces (infile);
|
|
|
1084 if (c != ')')
|
|
|
1085 fatal_expected_char (infile, ')', c);
|
|
|
1086 }
|
|
|
1087
|
|
|
1088 set_rtx_ptr_loc (stringbuf, read_rtx_filename, old_lineno);
|
|
|
1089 return stringbuf;
|
|
|
1090 }
|
|
|
1091
|
|
|
1092 /* Provide a version of a function to read a long long if the system does
|
|
|
1093 not provide one. */
|
|
|
1094 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !defined(HAVE_ATOLL) && !defined(HAVE_ATOQ)
|
|
|
1095 HOST_WIDE_INT atoll (const char *);
|
|
|
1096
|
|
|
1097 HOST_WIDE_INT
|
|
|
1098 atoll (const char *p)
|
|
|
1099 {
|
|
|
1100 int neg = 0;
|
|
|
1101 HOST_WIDE_INT tmp_wide;
|
|
|
1102
|
|
|
1103 while (ISSPACE (*p))
|
|
|
1104 p++;
|
|
|
1105 if (*p == '-')
|
|
|
1106 neg = 1, p++;
|
|
|
1107 else if (*p == '+')
|
|
|
1108 p++;
|
|
|
1109
|
|
|
1110 tmp_wide = 0;
|
|
|
1111 while (ISDIGIT (*p))
|
|
|
1112 {
|
|
|
1113 HOST_WIDE_INT new_wide = tmp_wide*10 + (*p - '0');
|
|
|
1114 if (new_wide < tmp_wide)
|
|
|
1115 {
|
|
|
1116 /* Return INT_MAX equiv on overflow. */
|
|
|
1117 tmp_wide = (~(unsigned HOST_WIDE_INT) 0) >> 1;
|
|
|
1118 break;
|
|
|
1119 }
|
|
|
1120 tmp_wide = new_wide;
|
|
|
1121 p++;
|
|
|
1122 }
|
|
|
1123
|
|
|
1124 if (neg)
|
|
|
1125 tmp_wide = -tmp_wide;
|
|
|
1126 return tmp_wide;
|
|
|
1127 }
|
|
|
1128 #endif
|
|
|
1129
|
|
|
1130 /* Given an object that starts with a char * name field, return a hash
|
|
|
1131 code for its name. */
|
|
|
1132 static hashval_t
|
|
|
1133 def_hash (const void *def)
|
|
|
1134 {
|
|
|
1135 unsigned result, i;
|
|
|
1136 const char *string = *(const char *const *) def;
|
|
|
1137
|
|
|
1138 for (result = i = 0; *string++ != '\0'; i++)
|
|
|
1139 result += ((unsigned char) *string << (i % CHAR_BIT));
|
|
|
1140 return result;
|
|
|
1141 }
|
|
|
1142
|
|
|
1143 /* Given two objects that start with char * name fields, return true if
|
|
|
1144 they have the same name. */
|
|
|
1145 static int
|
|
|
1146 def_name_eq_p (const void *def1, const void *def2)
|
|
|
1147 {
|
|
|
1148 return ! strcmp (*(const char *const *) def1,
|
|
|
1149 *(const char *const *) def2);
|
|
|
1150 }
|
|
|
1151
|
|
|
1152 /* INFILE is a FILE pointer to read text from. TMP_CHAR is a buffer suitable
|
|
|
1153 to read a name or number into. Process a define_constants directive,
|
|
|
1154 starting with the optional space after the "define_constants". */
|
|
|
1155 static void
|
|
|
1156 read_constants (FILE *infile, char *tmp_char)
|
|
|
1157 {
|
|
|
1158 int c;
|
|
|
1159 htab_t defs;
|
|
|
1160
|
|
|
1161 c = read_skip_spaces (infile);
|
|
|
1162 if (c != '[')
|
|
|
1163 fatal_expected_char (infile, '[', c);
|
|
|
1164 defs = md_constants;
|
|
|
1165 if (! defs)
|
|
|
1166 defs = htab_create (32, def_hash, def_name_eq_p, (htab_del) 0);
|
|
|
1167 /* Disable constant expansion during definition processing. */
|
|
|
1168 md_constants = 0;
|
|
|
1169 while ( (c = read_skip_spaces (infile)) != ']')
|
|
|
1170 {
|
|
|
1171 struct md_constant *def;
|
|
|
1172 void **entry_ptr;
|
|
|
1173
|
|
|
1174 if (c != '(')
|
|
|
1175 fatal_expected_char (infile, '(', c);
|
|
|
1176 def = XNEW (struct md_constant);
|
|
|
1177 def->name = tmp_char;
|
|
|
1178 read_name (tmp_char, infile);
|
|
|
1179 entry_ptr = htab_find_slot (defs, def, INSERT);
|
|
|
1180 if (! *entry_ptr)
|
|
|
1181 def->name = xstrdup (tmp_char);
|
|
|
1182 c = read_skip_spaces (infile);
|
|
|
1183 ungetc (c, infile);
|
|
|
1184 read_name (tmp_char, infile);
|
|
|
1185 if (! *entry_ptr)
|
|
|
1186 {
|
|
|
1187 def->value = xstrdup (tmp_char);
|
|
|
1188 *entry_ptr = def;
|
|
|
1189 }
|
|
|
1190 else
|
|
|
1191 {
|
|
|
1192 def = (struct md_constant *) *entry_ptr;
|
|
|
1193 if (strcmp (def->value, tmp_char))
|
|
|
1194 fatal_with_file_and_line (infile,
|
|
|
1195 "redefinition of %s, was %s, now %s",
|
|
|
1196 def->name, def->value, tmp_char);
|
|
|
1197 }
|
|
|
1198 c = read_skip_spaces (infile);
|
|
|
1199 if (c != ')')
|
|
|
1200 fatal_expected_char (infile, ')', c);
|
|
|
1201 }
|
|
|
1202 md_constants = defs;
|
|
|
1203 c = read_skip_spaces (infile);
|
|
|
1204 if (c != ')')
|
|
|
1205 fatal_expected_char (infile, ')', c);
|
|
|
1206 }
|
|
|
1207
|
|
|
1208 /* For every constant definition, call CALLBACK with two arguments:
|
|
|
1209 a pointer a pointer to the constant definition and INFO.
|
|
|
1210 Stops when CALLBACK returns zero. */
|
|
|
1211 void
|
|
|
1212 traverse_md_constants (htab_trav callback, void *info)
|
|
|
1213 {
|
|
|
1214 if (md_constants)
|
|
|
1215 htab_traverse (md_constants, callback, info);
|
|
|
1216 }
|
|
|
1217
|
|
|
1218 /* INFILE is a FILE pointer to read text from. TMP_CHAR is a buffer
|
|
|
1219 suitable to read a name or number into. Process a
|
|
|
1220 define_conditions directive, starting with the optional space after
|
|
|
1221 the "define_conditions". The directive looks like this:
|
|
|
1222
|
|
|
1223 (define_conditions [
|
|
|
1224 (number "string")
|
|
|
1225 (number "string")
|
|
|
1226 ...
|
|
|
1227 ])
|
|
|
1228
|
|
|
1229 It's not intended to appear in machine descriptions. It is
|
|
|
1230 generated by (the program generated by) genconditions.c, and
|
|
|
1231 slipped in at the beginning of the sequence of MD files read by
|
|
|
1232 most of the other generators. */
|
|
|
1233 static void
|
|
|
1234 read_conditions (FILE *infile, char *tmp_char)
|
|
|
1235 {
|
|
|
1236 int c;
|
|
|
1237
|
|
|
1238 c = read_skip_spaces (infile);
|
|
|
1239 if (c != '[')
|
|
|
1240 fatal_expected_char (infile, '[', c);
|
|
|
1241
|
|
|
1242 while ( (c = read_skip_spaces (infile)) != ']')
|
|
|
1243 {
|
|
|
1244 char *expr;
|
|
|
1245 int value;
|
|
|
1246
|
|
|
1247 if (c != '(')
|
|
|
1248 fatal_expected_char (infile, '(', c);
|
|
|
1249
|
|
|
1250 read_name (tmp_char, infile);
|
|
|
1251 validate_const_int (infile, tmp_char);
|
|
|
1252 value = atoi (tmp_char);
|
|
|
1253
|
|
|
1254 c = read_skip_spaces (infile);
|
|
|
1255 if (c != '"')
|
|
|
1256 fatal_expected_char (infile, '"', c);
|
|
|
1257 expr = read_quoted_string (infile);
|
|
|
1258
|
|
|
1259 c = read_skip_spaces (infile);
|
|
|
1260 if (c != ')')
|
|
|
1261 fatal_expected_char (infile, ')', c);
|
|
|
1262
|
|
|
1263 add_c_test (expr, value);
|
|
|
1264 }
|
|
|
1265 c = read_skip_spaces (infile);
|
|
|
1266 if (c != ')')
|
|
|
1267 fatal_expected_char (infile, ')', c);
|
|
|
1268 }
|
|
|
1269
|
|
|
1270 static void
|
|
|
1271 validate_const_int (FILE *infile, const char *string)
|
|
|
1272 {
|
|
|
1273 const char *cp;
|
|
|
1274 int valid = 1;
|
|
|
1275
|
|
|
1276 cp = string;
|
|
|
1277 while (*cp && ISSPACE (*cp))
|
|
|
1278 cp++;
|
|
|
1279 if (*cp == '-' || *cp == '+')
|
|
|
1280 cp++;
|
|
|
1281 if (*cp == 0)
|
|
|
1282 valid = 0;
|
|
|
1283 for (; *cp; cp++)
|
|
|
1284 if (! ISDIGIT (*cp))
|
|
|
1285 valid = 0;
|
|
|
1286 if (!valid)
|
|
|
1287 fatal_with_file_and_line (infile, "invalid decimal constant \"%s\"\n", string);
|
|
|
1288 }
|
|
|
1289
|
|
|
1290 /* Search GROUP for a mode or code called NAME and return its numerical
|
|
|
1291 identifier. INFILE is the file that contained NAME. */
|
|
|
1292
|
|
|
1293 static int
|
|
|
1294 find_iterator (struct iterator_group *group, const char *name, FILE *infile)
|
|
|
1295 {
|
|
|
1296 struct mapping *m;
|
|
|
1297
|
|
|
1298 m = (struct mapping *) htab_find (group->iterators, &name);
|
|
|
1299 if (m != 0)
|
|
|
1300 return m->index + group->num_builtins;
|
|
|
1301 return group->find_builtin (name, infile);
|
|
|
1302 }
|
|
|
1303
|
|
|
1304 /* Finish reading a declaration of the form:
|
|
|
1305
|
|
|
1306 (define... <name> [<value1> ... <valuen>])
|
|
|
1307
|
|
|
1308 from INFILE, where each <valuei> is either a bare symbol name or a
|
|
|
1309 "(<name> <string>)" pair. The "(define..." part has already been read.
|
|
|
1310
|
|
|
1311 Represent the declaration as a "mapping" structure; add it to TABLE
|
|
|
1312 (which belongs to GROUP) and return it. */
|
|
|
1313
|
|
|
1314 static struct mapping *
|
|
|
1315 read_mapping (struct iterator_group *group, htab_t table, FILE *infile)
|
|
|
1316 {
|
|
|
1317 char tmp_char[256];
|
|
|
1318 struct mapping *m;
|
|
|
1319 struct map_value **end_ptr;
|
|
|
1320 const char *string;
|
|
|
1321 int number, c;
|
|
|
1322
|
|
|
1323 /* Read the mapping name and create a structure for it. */
|
|
|
1324 read_name (tmp_char, infile);
|
|
|
1325 m = add_mapping (group, table, tmp_char, infile);
|
|
|
1326
|
|
|
1327 c = read_skip_spaces (infile);
|
|
|
1328 if (c != '[')
|
|
|
1329 fatal_expected_char (infile, '[', c);
|
|
|
1330
|
|
|
1331 /* Read each value. */
|
|
|
1332 end_ptr = &m->values;
|
|
|
1333 c = read_skip_spaces (infile);
|
|
|
1334 do
|
|
|
1335 {
|
|
|
1336 if (c != '(')
|
|
|
1337 {
|
|
|
1338 /* A bare symbol name that is implicitly paired to an
|
|
|
1339 empty string. */
|
|
|
1340 ungetc (c, infile);
|
|
|
1341 read_name (tmp_char, infile);
|
|
|
1342 string = "";
|
|
|
1343 }
|
|
|
1344 else
|
|
|
1345 {
|
|
|
1346 /* A "(name string)" pair. */
|
|
|
1347 read_name (tmp_char, infile);
|
|
|
1348 string = read_string (infile, false);
|
|
|
1349 c = read_skip_spaces (infile);
|
|
|
1350 if (c != ')')
|
|
|
1351 fatal_expected_char (infile, ')', c);
|
|
|
1352 }
|
|
|
1353 number = group->find_builtin (tmp_char, infile);
|
|
|
1354 end_ptr = add_map_value (end_ptr, number, string);
|
|
|
1355 c = read_skip_spaces (infile);
|
|
|
1356 }
|
|
|
1357 while (c != ']');
|
|
|
1358
|
|
|
1359 c = read_skip_spaces (infile);
|
|
|
1360 if (c != ')')
|
|
|
1361 fatal_expected_char (infile, ')', c);
|
|
|
1362
|
|
|
1363 return m;
|
|
|
1364 }
|
|
|
1365
|
|
|
1366 /* Check newly-created code iterator ITERATOR to see whether every code has the
|
|
|
1367 same format. Initialize the iterator's entry in bellwether_codes. */
|
|
|
1368
|
|
|
1369 static void
|
|
|
1370 check_code_iterator (struct mapping *iterator, FILE *infile)
|
|
|
1371 {
|
|
|
1372 struct map_value *v;
|
|
|
1373 enum rtx_code bellwether;
|
|
|
1374
|
|
|
1375 bellwether = (enum rtx_code) iterator->values->number;
|
|
|
1376 for (v = iterator->values->next; v != 0; v = v->next)
|
|
|
1377 if (strcmp (GET_RTX_FORMAT (bellwether), GET_RTX_FORMAT (v->number)) != 0)
|
|
|
1378 fatal_with_file_and_line (infile, "code iterator `%s' combines "
|
|
|
1379 "different rtx formats", iterator->name);
|
|
|
1380
|
|
|
1381 bellwether_codes = XRESIZEVEC (enum rtx_code, bellwether_codes,
|
|
|
1382 iterator->index + 1);
|
|
|
1383 bellwether_codes[iterator->index] = bellwether;
|
|
|
1384 }
|
|
|
1385
|
|
|
1386 /* Read an rtx in printed representation from INFILE and store its
|
|
|
1387 core representation in *X. Also store the line number of the
|
|
|
1388 opening '(' in *LINENO. Return true on success or false if the
|
|
|
1389 end of file has been reached.
|
|
|
1390
|
|
|
1391 read_rtx is not used in the compiler proper, but rather in
|
|
|
1392 the utilities gen*.c that construct C code from machine descriptions. */
|
|
|
1393
|
|
|
1394 bool
|
|
|
1395 read_rtx (FILE *infile, rtx *x, int *lineno)
|
|
|
1396 {
|
|
|
1397 static rtx queue_head, queue_next;
|
|
|
1398 static int queue_lineno;
|
|
|
1399 int c;
|
|
|
1400
|
|
|
1401 /* Do one-time initialization. */
|
|
|
1402 if (queue_head == 0)
|
|
|
1403 {
|
|
|
1404 initialize_iterators ();
|
|
|
1405 obstack_init (&string_obstack);
|
|
|
1406 queue_head = rtx_alloc (EXPR_LIST);
|
|
|
1407 ptr_locs = htab_create (161, leading_ptr_hash, leading_ptr_eq_p, 0);
|
|
|
1408 obstack_init (&ptr_loc_obstack);
|
|
|
1409 joined_conditions = htab_create (161, leading_ptr_hash,
|
|
|
1410 leading_ptr_eq_p, 0);
|
|
|
1411 obstack_init (&joined_conditions_obstack);
|
|
|
1412 }
|
|
|
1413
|
|
|
1414 if (queue_next == 0)
|
|
|
1415 {
|
|
|
1416 struct map_value *mode_maps;
|
|
|
1417 struct iterator_traverse_data mtd;
|
|
|
1418 rtx from_file;
|
|
|
1419
|
|
|
1420 c = read_skip_spaces (infile);
|
|
|
1421 if (c == EOF)
|
|
|
1422 return false;
|
|
|
1423 ungetc (c, infile);
|
|
|
1424
|
|
|
1425 queue_lineno = read_rtx_lineno;
|
|
|
1426 mode_maps = 0;
|
|
|
1427 from_file = read_rtx_1 (infile, &mode_maps);
|
|
|
1428 if (from_file == 0)
|
|
|
1429 return false; /* This confuses a top level (nil) with end of
|
|
|
1430 file, but a top level (nil) would have
|
|
|
1431 crashed our caller anyway. */
|
|
|
1432
|
|
|
1433 queue_next = queue_head;
|
|
|
1434 XEXP (queue_next, 0) = from_file;
|
|
|
1435 XEXP (queue_next, 1) = 0;
|
|
|
1436
|
|
|
1437 mtd.queue = queue_next;
|
|
|
1438 mtd.mode_maps = mode_maps;
|
|
|
1439 mtd.infile = infile;
|
|
|
1440 mtd.unknown_mode_attr = mode_maps ? mode_maps->string : NULL;
|
|
|
1441 htab_traverse (modes.iterators, apply_iterator_traverse, &mtd);
|
|
|
1442 htab_traverse (codes.iterators, apply_iterator_traverse, &mtd);
|
|
|
1443 if (mtd.unknown_mode_attr)
|
|
|
1444 fatal_with_file_and_line (infile,
|
|
|
1445 "undefined attribute '%s' used for mode",
|
|
|
1446 mtd.unknown_mode_attr);
|
|
|
1447 }
|
|
|
1448
|
|
|
1449 *x = XEXP (queue_next, 0);
|
|
|
1450 *lineno = queue_lineno;
|
|
|
1451 queue_next = XEXP (queue_next, 1);
|
|
|
1452
|
|
|
1453 return true;
|
|
|
1454 }
|
|
|
1455
|
|
|
1456 /* Subroutine of read_rtx that reads one construct from INFILE but
|
|
|
1457 doesn't apply any iterators. */
|
|
|
1458
|
|
|
1459 static rtx
|
|
|
1460 read_rtx_1 (FILE *infile, struct map_value **mode_maps)
|
|
|
1461 {
|
|
|
1462 int i;
|
|
|
1463 RTX_CODE real_code, bellwether_code;
|
|
|
1464 const char *format_ptr;
|
|
|
1465 /* tmp_char is a buffer used for reading decimal integers
|
|
|
1466 and names of rtx types and machine modes.
|
|
|
1467 Therefore, 256 must be enough. */
|
|
|
1468 char tmp_char[256];
|
|
|
1469 rtx return_rtx;
|
|
|
1470 int c;
|
|
|
1471 int tmp_int;
|
|
|
1472 HOST_WIDE_INT tmp_wide;
|
|
|
1473
|
|
|
1474 /* Linked list structure for making RTXs: */
|
|
|
1475 struct rtx_list
|
|
|
1476 {
|
|
|
1477 struct rtx_list *next;
|
|
|
1478 rtx value; /* Value of this node. */
|
|
|
1479 };
|
|
|
1480
|
|
|
1481 again:
|
|
|
1482 c = read_skip_spaces (infile); /* Should be open paren. */
|
|
|
1483
|
|
|
1484 if (c == EOF)
|
|
|
1485 return 0;
|
|
|
1486
|
|
|
1487 if (c != '(')
|
|
|
1488 fatal_expected_char (infile, '(', c);
|
|
|
1489
|
|
|
1490 read_name (tmp_char, infile);
|
|
|
1491 if (strcmp (tmp_char, "nil") == 0)
|
|
|
1492 {
|
|
|
1493 /* (nil) stands for an expression that isn't there. */
|
|
|
1494 c = read_skip_spaces (infile);
|
|
|
1495 if (c != ')')
|
|
|
1496 fatal_expected_char (infile, ')', c);
|
|
|
1497 return 0;
|
|
|
1498 }
|
|
|
1499 if (strcmp (tmp_char, "define_constants") == 0)
|
|
|
1500 {
|
|
|
1501 read_constants (infile, tmp_char);
|
|
|
1502 goto again;
|
|
|
1503 }
|
|
|
1504 if (strcmp (tmp_char, "define_conditions") == 0)
|
|
|
1505 {
|
|
|
1506 read_conditions (infile, tmp_char);
|
|
|
1507 goto again;
|
|
|
1508 }
|
|
|
1509 if (strcmp (tmp_char, "define_mode_attr") == 0)
|
|
|
1510 {
|
|
|
1511 read_mapping (&modes, modes.attrs, infile);
|
|
|
1512 goto again;
|
|
|
1513 }
|
|
|
1514 if (strcmp (tmp_char, "define_mode_iterator") == 0)
|
|
|
1515 {
|
|
|
1516 read_mapping (&modes, modes.iterators, infile);
|
|
|
1517 goto again;
|
|
|
1518 }
|
|
|
1519 if (strcmp (tmp_char, "define_code_attr") == 0)
|
|
|
1520 {
|
|
|
1521 read_mapping (&codes, codes.attrs, infile);
|
|
|
1522 goto again;
|
|
|
1523 }
|
|
|
1524 if (strcmp (tmp_char, "define_code_iterator") == 0)
|
|
|
1525 {
|
|
|
1526 check_code_iterator (read_mapping (&codes, codes.iterators, infile),
|
|
|
1527 infile);
|
|
|
1528 goto again;
|
|
|
1529 }
|
|
|
1530 real_code = (enum rtx_code) find_iterator (&codes, tmp_char, infile);
|
|
|
1531 bellwether_code = BELLWETHER_CODE (real_code);
|
|
|
1532
|
|
|
1533 /* If we end up with an insn expression then we free this space below. */
|
|
|
1534 return_rtx = rtx_alloc (bellwether_code);
|
|
|
1535 format_ptr = GET_RTX_FORMAT (bellwether_code);
|
|
|
1536 PUT_CODE (return_rtx, real_code);
|
|
|
1537
|
|
|
1538 /* If what follows is `: mode ', read it and
|
|
|
1539 store the mode in the rtx. */
|
|
|
1540
|
|
|
1541 i = read_skip_spaces (infile);
|
|
|
1542 if (i == ':')
|
|
|
1543 {
|
|
|
1544 unsigned int mode;
|
|
|
1545
|
|
|
1546 read_name (tmp_char, infile);
|
|
|
1547 if (tmp_char[0] != '<' || tmp_char[strlen (tmp_char) - 1] != '>')
|
|
|
1548 mode = find_iterator (&modes, tmp_char, infile);
|
|
|
1549 else
|
|
|
1550 mode = mode_attr_index (mode_maps, tmp_char);
|
|
|
1551 PUT_MODE (return_rtx, (enum machine_mode) mode);
|
|
|
1552 if (GET_MODE (return_rtx) != mode)
|
|
|
1553 fatal_with_file_and_line (infile, "mode too large");
|
|
|
1554 }
|
|
|
1555 else
|
|
|
1556 ungetc (i, infile);
|
|
|
1557
|
|
|
1558 for (i = 0; format_ptr[i] != 0; i++)
|
|
|
1559 switch (format_ptr[i])
|
|
|
1560 {
|
|
|
1561 /* 0 means a field for internal use only.
|
|
|
1562 Don't expect it to be present in the input. */
|
|
|
1563 case '0':
|
|
|
1564 break;
|
|
|
1565
|
|
|
1566 case 'e':
|
|
|
1567 case 'u':
|
|
|
1568 XEXP (return_rtx, i) = read_rtx_1 (infile, mode_maps);
|
|
|
1569 break;
|
|
|
1570
|
|
|
1571 case 'V':
|
|
|
1572 /* 'V' is an optional vector: if a closeparen follows,
|
|
|
1573 just store NULL for this element. */
|
|
|
1574 c = read_skip_spaces (infile);
|
|
|
1575 ungetc (c, infile);
|
|
|
1576 if (c == ')')
|
|
|
1577 {
|
|
|
1578 XVEC (return_rtx, i) = 0;
|
|
|
1579 break;
|
|
|
1580 }
|
|
|
1581 /* Now process the vector. */
|
|
|
1582
|
|
|
1583 case 'E':
|
|
|
1584 {
|
|
|
1585 /* Obstack to store scratch vector in. */
|
|
|
1586 struct obstack vector_stack;
|
|
|
1587 int list_counter = 0;
|
|
|
1588 rtvec return_vec = NULL_RTVEC;
|
|
|
1589
|
|
|
1590 c = read_skip_spaces (infile);
|
|
|
1591 if (c != '[')
|
|
|
1592 fatal_expected_char (infile, '[', c);
|
|
|
1593
|
|
|
1594 /* Add expressions to a list, while keeping a count. */
|
|
|
1595 obstack_init (&vector_stack);
|
|
|
1596 while ((c = read_skip_spaces (infile)) && c != ']')
|
|
|
1597 {
|
|
|
1598 ungetc (c, infile);
|
|
|
1599 list_counter++;
|
|
|
1600 obstack_ptr_grow (&vector_stack, read_rtx_1 (infile, mode_maps));
|
|
|
1601 }
|
|
|
1602 if (list_counter > 0)
|
|
|
1603 {
|
|
|
1604 return_vec = rtvec_alloc (list_counter);
|
|
|
1605 memcpy (&return_vec->elem[0], obstack_finish (&vector_stack),
|
|
|
1606 list_counter * sizeof (rtx));
|
|
|
1607 }
|
|
|
1608 else if (format_ptr[i] == 'E')
|
|
|
1609 fatal_with_file_and_line (infile,
|
|
|
1610 "vector must have at least one element");
|
|
|
1611 XVEC (return_rtx, i) = return_vec;
|
|
|
1612 obstack_free (&vector_stack, NULL);
|
|
|
1613 /* close bracket gotten */
|
|
|
1614 }
|
|
|
1615 break;
|
|
|
1616
|
|
|
1617 case 'S':
|
|
|
1618 case 'T':
|
|
|
1619 case 's':
|
|
|
1620 {
|
|
|
1621 char *stringbuf;
|
|
|
1622 int star_if_braced;
|
|
|
1623
|
|
|
1624 c = read_skip_spaces (infile);
|
|
|
1625 ungetc (c, infile);
|
|
|
1626 if (c == ')')
|
|
|
1627 {
|
|
|
1628 /* 'S' fields are optional and should be NULL if no string
|
|
|
1629 was given. Also allow normal 's' and 'T' strings to be
|
|
|
1630 omitted, treating them in the same way as empty strings. */
|
|
|
1631 XSTR (return_rtx, i) = (format_ptr[i] == 'S' ? NULL : "");
|
|
|
1632 break;
|
|
|
1633 }
|
|
|
1634
|
|
|
1635 /* The output template slot of a DEFINE_INSN,
|
|
|
1636 DEFINE_INSN_AND_SPLIT, or DEFINE_PEEPHOLE automatically
|
|
|
1637 gets a star inserted as its first character, if it is
|
|
|
1638 written with a brace block instead of a string constant. */
|
|
|
1639 star_if_braced = (format_ptr[i] == 'T');
|
|
|
1640
|
|
|
1641 stringbuf = read_string (infile, star_if_braced);
|
|
|
1642
|
|
|
1643 /* For insn patterns, we want to provide a default name
|
|
|
1644 based on the file and line, like "*foo.md:12", if the
|
|
|
1645 given name is blank. These are only for define_insn and
|
|
|
1646 define_insn_and_split, to aid debugging. */
|
|
|
1647 if (*stringbuf == '\0'
|
|
|
1648 && i == 0
|
|
|
1649 && (GET_CODE (return_rtx) == DEFINE_INSN
|
|
|
1650 || GET_CODE (return_rtx) == DEFINE_INSN_AND_SPLIT))
|
|
|
1651 {
|
|
|
1652 char line_name[20];
|
|
|
1653 const char *fn = (read_rtx_filename ? read_rtx_filename : "rtx");
|
|
|
1654 const char *slash;
|
|
|
1655 for (slash = fn; *slash; slash ++)
|
|
|
1656 if (*slash == '/' || *slash == '\\' || *slash == ':')
|
|
|
1657 fn = slash + 1;
|
|
|
1658 obstack_1grow (&string_obstack, '*');
|
|
|
1659 obstack_grow (&string_obstack, fn, strlen (fn));
|
|
|
1660 sprintf (line_name, ":%d", read_rtx_lineno);
|
|
|
1661 obstack_grow (&string_obstack, line_name, strlen (line_name)+1);
|
|
|
1662 stringbuf = XOBFINISH (&string_obstack, char *);
|
|
|
1663 }
|
|
|
1664
|
|
|
1665 if (star_if_braced)
|
|
|
1666 XTMPL (return_rtx, i) = stringbuf;
|
|
|
1667 else
|
|
|
1668 XSTR (return_rtx, i) = stringbuf;
|
|
|
1669 }
|
|
|
1670 break;
|
|
|
1671
|
|
|
1672 case 'w':
|
|
|
1673 read_name (tmp_char, infile);
|
|
|
1674 validate_const_int (infile, tmp_char);
|
|
|
1675 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
|
|
|
1676 tmp_wide = atoi (tmp_char);
|
|
|
1677 #else
|
|
|
1678 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
|
|
|
1679 tmp_wide = atol (tmp_char);
|
|
|
1680 #else
|
|
|
1681 /* Prefer atoll over atoq, since the former is in the ISO C99 standard.
|
|
|
1682 But prefer not to use our hand-rolled function above either. */
|
|
|
1683 #if defined(HAVE_ATOLL) || !defined(HAVE_ATOQ)
|
|
|
1684 tmp_wide = atoll (tmp_char);
|
|
|
1685 #else
|
|
|
1686 tmp_wide = atoq (tmp_char);
|
|
|
1687 #endif
|
|
|
1688 #endif
|
|
|
1689 #endif
|
|
|
1690 XWINT (return_rtx, i) = tmp_wide;
|
|
|
1691 break;
|
|
|
1692
|
|
|
1693 case 'i':
|
|
|
1694 case 'n':
|
|
|
1695 read_name (tmp_char, infile);
|
|
|
1696 validate_const_int (infile, tmp_char);
|
|
|
1697 tmp_int = atoi (tmp_char);
|
|
|
1698 XINT (return_rtx, i) = tmp_int;
|
|
|
1699 break;
|
|
|
1700
|
|
|
1701 default:
|
|
|
1702 gcc_unreachable ();
|
|
|
1703 }
|
|
|
1704
|
|
|
1705 c = read_skip_spaces (infile);
|
|
|
1706 if (c != ')')
|
|
|
1707 {
|
|
|
1708 /* Syntactic sugar for AND and IOR, allowing Lisp-like
|
|
|
1709 arbitrary number of arguments for them. */
|
|
|
1710 if (c == '(' && (GET_CODE (return_rtx) == AND
|
|
|
1711 || GET_CODE (return_rtx) == IOR))
|
|
|
1712 return read_rtx_variadic (infile, mode_maps, return_rtx);
|
|
|
1713 else
|
|
|
1714 fatal_expected_char (infile, ')', c);
|
|
|
1715 }
|
|
|
1716
|
|
|
1717 return return_rtx;
|
|
|
1718 }
|
|
|
1719
|
|
|
1720 /* Mutually recursive subroutine of read_rtx which reads
|
|
|
1721 (thing x1 x2 x3 ...) and produces RTL as if
|
|
|
1722 (thing x1 (thing x2 (thing x3 ...))) had been written.
|
|
|
1723 When called, FORM is (thing x1 x2), and the file position
|
|
|
1724 is just past the leading parenthesis of x3. Only works
|
|
|
1725 for THINGs which are dyadic expressions, e.g. AND, IOR. */
|
|
|
1726 static rtx
|
|
|
1727 read_rtx_variadic (FILE *infile, struct map_value **mode_maps, rtx form)
|
|
|
1728 {
|
|
|
1729 char c = '(';
|
|
|
1730 rtx p = form, q;
|
|
|
1731
|
|
|
1732 do
|
|
|
1733 {
|
|
|
1734 ungetc (c, infile);
|
|
|
1735
|
|
|
1736 q = rtx_alloc (GET_CODE (p));
|
|
|
1737 PUT_MODE (q, GET_MODE (p));
|
|
|
1738
|
|
|
1739 XEXP (q, 0) = XEXP (p, 1);
|
|
|
1740 XEXP (q, 1) = read_rtx_1 (infile, mode_maps);
|
|
|
1741
|
|
|
1742 XEXP (p, 1) = q;
|
|
|
1743 p = q;
|
|
|
1744 c = read_skip_spaces (infile);
|
|
|
1745 }
|
|
|
1746 while (c == '(');
|
|
|
1747
|
|
|
1748 if (c != ')')
|
|
|
1749 fatal_expected_char (infile, ')', c);
|
|
|
1750
|
|
|
1751 return form;
|
|
|
1752 }
|
