b26f56aa258f3d3cf0bd4f8375446dd6736cf7ce
1 /* Generate code from machine description to extract operands from insn as rtl.
2 Copyright (C) 1987-2019 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
28 #include "gensupport.h"
30 /* This structure contains all the information needed to describe one
31 set of extractions methods. Each method may be used by more than
32 one pattern if the operands are in the same place.
34 The string for each operand describes that path to the operand and
35 contains `0' through `9' when going into an expression and `a' through
36 `z' then 'A' through to 'Z' when going into a vector. We assume here that
37 only the first operand of an rtl expression is a vector. genrecog.c makes
38 the same assumption (and uses the same representation) and it is currently
45 unsigned int op_count
;
46 unsigned int dup_count
;
50 struct code_ptr
*insns
;
51 struct extraction
*next
;
54 /* Holds a single insn code that uses an extraction method. */
58 struct code_ptr
*next
;
61 /* All extractions needed for this machine description. */
62 static struct extraction
*extractions
;
64 /* All insn codes for old-style peepholes. */
65 static struct code_ptr
*peepholes
;
67 /* This structure is used by gen_insn and walk_rtx to accumulate the
68 data that will be used to produce an extractions structure. */
73 accum_extract () : oplocs (10), duplocs (10), dupnums (10), pathstr (20) {}
75 auto_vec
<locstr
> oplocs
;
76 auto_vec
<locstr
> duplocs
;
77 auto_vec
<int> dupnums
;
78 auto_vec
<char> pathstr
;
81 /* Forward declarations. */
82 static void walk_rtx (md_rtx_info
*, rtx
, struct accum_extract
*);
84 #define UPPER_OFFSET ('A' - ('z' - 'a' + 1))
86 /* Convert integer OPERAND into a character - either into [a-zA-Z] for vector
87 operands or [0-9] for integer operands - and push onto the end of the path
90 push_pathstr_operand (int operand
, bool is_vector
,
91 struct accum_extract
*acc
)
93 if (is_vector
&& 'a' + operand
> 'z')
94 acc
->pathstr
.safe_push (operand
+ UPPER_OFFSET
);
96 acc
->pathstr
.safe_push (operand
+ 'a');
98 acc
->pathstr
.safe_push (operand
+ '0');
102 gen_insn (md_rtx_info
*info
)
105 unsigned int op_count
, dup_count
, j
;
106 struct extraction
*p
;
107 struct code_ptr
*link
;
108 struct accum_extract acc
;
110 /* Walk the insn's pattern, remembering at all times the path
111 down to the walking point. */
113 rtx insn
= info
->def
;
114 if (XVECLEN (insn
, 1) == 1)
115 walk_rtx (info
, XVECEXP (insn
, 1, 0), &acc
);
117 for (i
= XVECLEN (insn
, 1) - 1; i
>= 0; i
--)
119 push_pathstr_operand (i
, true, &acc
);
120 walk_rtx (info
, XVECEXP (insn
, 1, i
), &acc
);
124 link
= XNEW (struct code_ptr
);
125 link
->insn_code
= info
->index
;
127 /* See if we find something that already had this extraction method. */
129 op_count
= acc
.oplocs
.length ();
130 dup_count
= acc
.duplocs
.length ();
131 gcc_assert (dup_count
== acc
.dupnums
.length ());
133 for (p
= extractions
; p
; p
= p
->next
)
135 if (p
->op_count
!= op_count
|| p
->dup_count
!= dup_count
)
138 for (j
= 0; j
< op_count
; j
++)
140 char *a
= p
->oplocs
[j
];
141 char *b
= acc
.oplocs
[j
];
142 if (a
!= b
&& (!a
|| !b
|| strcmp (a
, b
)))
149 for (j
= 0; j
< dup_count
; j
++)
150 if (p
->dupnums
[j
] != acc
.dupnums
[j
]
151 || strcmp (p
->duplocs
[j
], acc
.duplocs
[j
]))
157 /* This extraction is the same as ours. Just link us in. */
158 link
->next
= p
->insns
;
163 /* Otherwise, make a new extraction method. We stash the arrays
164 after the extraction structure in memory. */
166 p
= XNEWVAR (struct extraction
, sizeof (struct extraction
)
167 + op_count
*sizeof (char *)
168 + dup_count
*sizeof (char *)
169 + dup_count
*sizeof (int));
170 p
->op_count
= op_count
;
171 p
->dup_count
= dup_count
;
172 p
->next
= extractions
;
177 p
->oplocs
= (char **)((char *)p
+ sizeof (struct extraction
));
178 p
->duplocs
= p
->oplocs
+ op_count
;
179 p
->dupnums
= (int *)(p
->duplocs
+ dup_count
);
181 memcpy (p
->oplocs
, acc
.oplocs
.address (), op_count
* sizeof (locstr
));
182 memcpy (p
->duplocs
, acc
.duplocs
.address (), dup_count
* sizeof (locstr
));
183 memcpy (p
->dupnums
, acc
.dupnums
.address (), dup_count
* sizeof (int));
186 /* Helper subroutine of walk_rtx: given a vec<locstr>, an index, and a
187 string, insert the string at the index, which should either already
188 exist and be NULL, or not yet exist within the vector. In the latter
189 case the vector is enlarged as appropriate. INFO describes the
190 containing define_* expression. */
192 VEC_safe_set_locstr (md_rtx_info
*info
, vec
<locstr
> *vp
,
193 unsigned int ix
, char *str
)
195 if (ix
< (*vp
).length ())
199 message_at (info
->loc
, "repeated operand number %d", ix
);
207 while (ix
> (*vp
).length ())
208 vp
->safe_push (NULL
);
213 /* Another helper subroutine of walk_rtx: given a vec<char>, convert it
214 to a NUL-terminated string in malloc memory. */
216 VEC_char_to_string (vec
<char> v
)
218 size_t n
= v
.length ();
219 char *s
= XNEWVEC (char, n
+ 1);
220 memcpy (s
, v
.address (), n
);
226 walk_rtx (md_rtx_info
*info
, rtx x
, struct accum_extract
*acc
)
246 VEC_safe_set_locstr (info
, &acc
->oplocs
, XINT (x
, 0),
247 VEC_char_to_string (acc
->pathstr
));
252 VEC_safe_set_locstr (info
, &acc
->oplocs
, XINT (x
, 0),
253 VEC_char_to_string (acc
->pathstr
));
255 for (i
= XVECLEN (x
, 2) - 1; i
>= 0; i
--)
257 push_pathstr_operand (i
, code
!= MATCH_OPERATOR
, acc
);
258 walk_rtx (info
, XVECEXP (x
, 2, i
), acc
);
266 acc
->duplocs
.safe_push (VEC_char_to_string (acc
->pathstr
));
267 acc
->dupnums
.safe_push (XINT (x
, 0));
269 if (code
== MATCH_DUP
)
272 for (i
= XVECLEN (x
, 1) - 1; i
>= 0; i
--)
274 push_pathstr_operand (i
, code
!= MATCH_OP_DUP
, acc
);
275 walk_rtx (info
, XVECEXP (x
, 1, i
), acc
);
284 fmt
= GET_RTX_FORMAT (code
);
285 len
= GET_RTX_LENGTH (code
);
286 for (i
= 0; i
< len
; i
++)
288 if (fmt
[i
] == 'e' || fmt
[i
] == 'u')
290 push_pathstr_operand (i
, false, acc
);
291 walk_rtx (info
, XEXP (x
, i
), acc
);
294 else if (fmt
[i
] == 'E')
297 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
299 push_pathstr_operand (j
, true, acc
);
300 walk_rtx (info
, XVECEXP (x
, i
, j
), acc
);
307 /* Given a PATH, representing a path down the instruction's
308 pattern from the root to a certain point, output code to
309 evaluate to the rtx at that point. */
312 print_path (const char *path
)
314 int len
= strlen (path
);
319 /* Don't emit "pat", since we may try to take the address of it,
320 which isn't what is intended. */
321 fputs ("PATTERN (insn)", stdout
);
325 /* We first write out the operations (XEXP or XVECEXP) in reverse
326 order, then write "pat", then the indices in forward order. */
328 for (i
= len
- 1; i
>= 0 ; i
--)
330 if (ISLOWER (path
[i
]) || ISUPPER (path
[i
]))
331 fputs ("XVECEXP (", stdout
);
332 else if (ISDIGIT (path
[i
]))
333 fputs ("XEXP (", stdout
);
338 fputs ("pat", stdout
);
340 for (i
= 0; i
< len
; i
++)
342 if (ISUPPER (path
[i
]))
343 printf (", 0, %d)", path
[i
] - UPPER_OFFSET
);
344 else if (ISLOWER (path
[i
]))
345 printf (", 0, %d)", path
[i
] - 'a');
346 else if (ISDIGIT (path
[i
]))
347 printf (", %d)", path
[i
] - '0');
356 /* N.B. Code below avoids putting squiggle braces in column 1 inside
357 a string, because this confuses some editors' syntax highlighting
361 /* Generated automatically by the program `genextract'\n\
362 from the machine description file `md'. */\n\
364 #define IN_TARGET_CODE 1\n\
365 #include \"config.h\"\n\
366 #include \"system.h\"\n\
367 #include \"coretypes.h\"\n\
369 #include \"rtl.h\"\n\
370 #include \"insn-config.h\"\n\
371 #include \"recog.h\"\n\
372 #include \"diagnostic-core.h\"\n\
374 /* This variable is used as the \"location\" of any missing operand\n\
375 whose numbers are skipped by a given pattern. */\n\
376 static rtx junk ATTRIBUTE_UNUSED;\n");
380 insn_extract (rtx_insn *insn)\n{\n\
381 rtx *ro = recog_data.operand;\n\
382 rtx **ro_loc = recog_data.operand_loc;\n\
383 rtx pat = PATTERN (insn);\n\
384 int i ATTRIBUTE_UNUSED; /* only for peepholes */\n\
386 if (flag_checking)\n\
388 memset (ro, 0xab, sizeof (*ro) * MAX_RECOG_OPERANDS);\n\
389 memset (ro_loc, 0xab, sizeof (*ro_loc) * MAX_RECOG_OPERANDS);\n\
393 switch (INSN_CODE (insn))\n\
396 /* Control reaches here if insn_extract has been called with an\n\
397 unrecognizable insn (code -1), or an insn whose INSN_CODE\n\
398 corresponds to a DEFINE_EXPAND in the machine description;\n\
399 either way, a bug. */\n\
400 if (INSN_CODE (insn) < 0)\n\
401 fatal_insn (\"unrecognizable insn:\", insn);\n\
403 fatal_insn (\"insn with invalid code number:\", insn);\n");
407 main (int argc
, const char **argv
)
410 struct extraction
*p
;
411 struct code_ptr
*link
;
414 progname
= "genextract";
416 if (!init_rtx_reader_args (argc
, argv
))
417 return (FATAL_EXIT_CODE
);
419 /* Read the machine description. */
422 while (read_md_rtx (&info
))
423 switch (GET_CODE (info
.def
))
429 case DEFINE_PEEPHOLE
:
431 struct code_ptr
*link
= XNEW (struct code_ptr
);
433 link
->insn_code
= info
.index
;
434 link
->next
= peepholes
;
444 return FATAL_EXIT_CODE
;
448 /* Write out code to handle peepholes and the insn_codes that it should
452 for (link
= peepholes
; link
; link
= link
->next
)
453 printf (" case %d:\n", link
->insn_code
);
455 /* The vector in the insn says how many operands it has.
456 And all it contains are operands. In fact, the vector was
457 created just for the sake of this function. We need to set the
458 location of the operands for sake of simplifications after
459 extraction, like eliminating subregs. */
460 puts (" for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)\n"
461 " ro[i] = *(ro_loc[i] = &XVECEXP (pat, 0, i));\n"
465 /* Write out all the ways to extract insn operands. */
466 for (p
= extractions
; p
; p
= p
->next
)
468 for (link
= p
->insns
; link
; link
= link
->next
)
471 name
= get_insn_name (i
);
473 printf (" case %d: /* %s */\n", i
, name
);
475 printf (" case %d:\n", i
);
478 for (i
= 0; i
< p
->op_count
; i
++)
480 if (p
->oplocs
[i
] == 0)
482 printf (" ro[%d] = const0_rtx;\n", i
);
483 printf (" ro_loc[%d] = &junk;\n", i
);
487 printf (" ro[%d] = *(ro_loc[%d] = &", i
, i
);
488 print_path (p
->oplocs
[i
]);
493 for (i
= 0; i
< p
->dup_count
; i
++)
495 printf (" recog_data.dup_loc[%d] = &", i
);
496 print_path (p
->duplocs
[i
]);
498 printf (" recog_data.dup_num[%d] = %d;\n", i
, p
->dupnums
[i
]);
506 return (ferror (stdout
) != 0 ? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
);