1 /* Assembler interface for targets using CGEN. -*- C -*-
2 CGEN: Cpu tools GENerator
3
4 THIS FILE IS MACHINE GENERATED WITH CGEN.
5 - the resultant file is machine generated, cgen-asm.in isn't
6
7 Copyright (C) 1996-2014 Free Software Foundation, Inc.
8
9 This file is part of libopcodes.
10
11 This library is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3, or (at your option)
14 any later version.
15
16 It is distributed in the hope that it will be useful, but WITHOUT
17 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
18 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
19 License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software Foundation, Inc.,
23 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
24
25
26 /* ??? Eventually more and more of this stuff can go to cpu-independent files.
27 Keep that in mind. */
28
29 #include "sysdep.h"
30 #include <stdio.h>
31 #include "ansidecl.h"
32 #include "bfd.h"
33 #include "symcat.h"
34 #include "fr30-desc.h"
35 #include "fr30-opc.h"
36 #include "opintl.h"
37 #include "xregex.h"
38 #include "libiberty.h"
39 #include "safe-ctype.h"
40
41 #undef min
42 #define min(a,b) ((a) < (b) ? (a) : (b))
43 #undef max
44 #define max(a,b) ((a) > (b) ? (a) : (b))
45
46 static const char * parse_insn_normal
47 (CGEN_CPU_DESC, const CGEN_INSN *, const char **, CGEN_FIELDS *);
48
49 /* -- assembler routines inserted here. */
50
51 /* -- asm.c */
52 /* Handle register lists for LDMx and STMx. */
53
54 static int
parse_register_number(const char ** strp)55 parse_register_number (const char **strp)
56 {
57 int regno;
58
59 if (**strp < '0' || **strp > '9')
60 return -1; /* Error. */
61 regno = **strp - '0';
62 ++*strp;
63
64 if (**strp >= '0' && **strp <= '9')
65 {
66 regno = regno * 10 + (**strp - '0');
67 ++*strp;
68 }
69
70 return regno;
71 }
72
73 static const char *
parse_register_list(CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,const char ** strp,int opindex ATTRIBUTE_UNUSED,unsigned long * valuep,int high_low,int load_store)74 parse_register_list (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
75 const char **strp,
76 int opindex ATTRIBUTE_UNUSED,
77 unsigned long *valuep,
78 int high_low, /* 0 == high, 1 == low. */
79 int load_store) /* 0 == load, 1 == store. */
80 {
81 *valuep = 0;
82 while (**strp && **strp != ')')
83 {
84 int regno;
85
86 if (**strp != 'R' && **strp != 'r')
87 break;
88 ++*strp;
89
90 regno = parse_register_number (strp);
91 if (regno == -1)
92 return _("Register number is not valid");
93 if (regno > 7 && !high_low)
94 return _("Register must be between r0 and r7");
95 if (regno < 8 && high_low)
96 return _("Register must be between r8 and r15");
97
98 if (high_low)
99 regno -= 8;
100
101 if (load_store) /* Mask is reversed for store. */
102 *valuep |= 0x80 >> regno;
103 else
104 *valuep |= 1 << regno;
105
106 if (**strp == ',')
107 {
108 if (*(*strp + 1) == ')')
109 break;
110 ++*strp;
111 }
112 }
113
114 if (!*strp || **strp != ')')
115 return _("Register list is not valid");
116
117 return NULL;
118 }
119
120 static const char *
parse_low_register_list_ld(CGEN_CPU_DESC cd,const char ** strp,int opindex,unsigned long * valuep)121 parse_low_register_list_ld (CGEN_CPU_DESC cd,
122 const char **strp,
123 int opindex,
124 unsigned long *valuep)
125 {
126 return parse_register_list (cd, strp, opindex, valuep,
127 0 /* Low. */, 0 /* Load. */);
128 }
129
130 static const char *
parse_hi_register_list_ld(CGEN_CPU_DESC cd,const char ** strp,int opindex,unsigned long * valuep)131 parse_hi_register_list_ld (CGEN_CPU_DESC cd,
132 const char **strp,
133 int opindex,
134 unsigned long *valuep)
135 {
136 return parse_register_list (cd, strp, opindex, valuep,
137 1 /* High. */, 0 /* Load. */);
138 }
139
140 static const char *
parse_low_register_list_st(CGEN_CPU_DESC cd,const char ** strp,int opindex,unsigned long * valuep)141 parse_low_register_list_st (CGEN_CPU_DESC cd,
142 const char **strp,
143 int opindex,
144 unsigned long *valuep)
145 {
146 return parse_register_list (cd, strp, opindex, valuep,
147 0 /* Low. */, 1 /* Store. */);
148 }
149
150 static const char *
parse_hi_register_list_st(CGEN_CPU_DESC cd,const char ** strp,int opindex,unsigned long * valuep)151 parse_hi_register_list_st (CGEN_CPU_DESC cd,
152 const char **strp,
153 int opindex,
154 unsigned long *valuep)
155 {
156 return parse_register_list (cd, strp, opindex, valuep,
157 1 /* High. */, 1 /* Store. */);
158 }
159
160 /* -- */
161
162 const char * fr30_cgen_parse_operand
163 (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);
164
165 /* Main entry point for operand parsing.
166
167 This function is basically just a big switch statement. Earlier versions
168 used tables to look up the function to use, but
169 - if the table contains both assembler and disassembler functions then
170 the disassembler contains much of the assembler and vice-versa,
171 - there's a lot of inlining possibilities as things grow,
172 - using a switch statement avoids the function call overhead.
173
174 This function could be moved into `parse_insn_normal', but keeping it
175 separate makes clear the interface between `parse_insn_normal' and each of
176 the handlers. */
177
178 const char *
fr30_cgen_parse_operand(CGEN_CPU_DESC cd,int opindex,const char ** strp,CGEN_FIELDS * fields)179 fr30_cgen_parse_operand (CGEN_CPU_DESC cd,
180 int opindex,
181 const char ** strp,
182 CGEN_FIELDS * fields)
183 {
184 const char * errmsg = NULL;
185 /* Used by scalar operands that still need to be parsed. */
186 long junk ATTRIBUTE_UNUSED;
187
188 switch (opindex)
189 {
190 case FR30_OPERAND_CRI :
191 errmsg = cgen_parse_keyword (cd, strp, & fr30_cgen_opval_cr_names, & fields->f_CRi);
192 break;
193 case FR30_OPERAND_CRJ :
194 errmsg = cgen_parse_keyword (cd, strp, & fr30_cgen_opval_cr_names, & fields->f_CRj);
195 break;
196 case FR30_OPERAND_R13 :
197 errmsg = cgen_parse_keyword (cd, strp, & fr30_cgen_opval_h_r13, & junk);
198 break;
199 case FR30_OPERAND_R14 :
200 errmsg = cgen_parse_keyword (cd, strp, & fr30_cgen_opval_h_r14, & junk);
201 break;
202 case FR30_OPERAND_R15 :
203 errmsg = cgen_parse_keyword (cd, strp, & fr30_cgen_opval_h_r15, & junk);
204 break;
205 case FR30_OPERAND_RI :
206 errmsg = cgen_parse_keyword (cd, strp, & fr30_cgen_opval_gr_names, & fields->f_Ri);
207 break;
208 case FR30_OPERAND_RIC :
209 errmsg = cgen_parse_keyword (cd, strp, & fr30_cgen_opval_gr_names, & fields->f_Ric);
210 break;
211 case FR30_OPERAND_RJ :
212 errmsg = cgen_parse_keyword (cd, strp, & fr30_cgen_opval_gr_names, & fields->f_Rj);
213 break;
214 case FR30_OPERAND_RJC :
215 errmsg = cgen_parse_keyword (cd, strp, & fr30_cgen_opval_gr_names, & fields->f_Rjc);
216 break;
217 case FR30_OPERAND_RS1 :
218 errmsg = cgen_parse_keyword (cd, strp, & fr30_cgen_opval_dr_names, & fields->f_Rs1);
219 break;
220 case FR30_OPERAND_RS2 :
221 errmsg = cgen_parse_keyword (cd, strp, & fr30_cgen_opval_dr_names, & fields->f_Rs2);
222 break;
223 case FR30_OPERAND_CC :
224 errmsg = cgen_parse_unsigned_integer (cd, strp, FR30_OPERAND_CC, (unsigned long *) (& fields->f_cc));
225 break;
226 case FR30_OPERAND_CCC :
227 errmsg = cgen_parse_unsigned_integer (cd, strp, FR30_OPERAND_CCC, (unsigned long *) (& fields->f_ccc));
228 break;
229 case FR30_OPERAND_DIR10 :
230 errmsg = cgen_parse_unsigned_integer (cd, strp, FR30_OPERAND_DIR10, (unsigned long *) (& fields->f_dir10));
231 break;
232 case FR30_OPERAND_DIR8 :
233 errmsg = cgen_parse_unsigned_integer (cd, strp, FR30_OPERAND_DIR8, (unsigned long *) (& fields->f_dir8));
234 break;
235 case FR30_OPERAND_DIR9 :
236 errmsg = cgen_parse_unsigned_integer (cd, strp, FR30_OPERAND_DIR9, (unsigned long *) (& fields->f_dir9));
237 break;
238 case FR30_OPERAND_DISP10 :
239 errmsg = cgen_parse_signed_integer (cd, strp, FR30_OPERAND_DISP10, (long *) (& fields->f_disp10));
240 break;
241 case FR30_OPERAND_DISP8 :
242 errmsg = cgen_parse_signed_integer (cd, strp, FR30_OPERAND_DISP8, (long *) (& fields->f_disp8));
243 break;
244 case FR30_OPERAND_DISP9 :
245 errmsg = cgen_parse_signed_integer (cd, strp, FR30_OPERAND_DISP9, (long *) (& fields->f_disp9));
246 break;
247 case FR30_OPERAND_I20 :
248 errmsg = cgen_parse_unsigned_integer (cd, strp, FR30_OPERAND_I20, (unsigned long *) (& fields->f_i20));
249 break;
250 case FR30_OPERAND_I32 :
251 errmsg = cgen_parse_unsigned_integer (cd, strp, FR30_OPERAND_I32, (unsigned long *) (& fields->f_i32));
252 break;
253 case FR30_OPERAND_I8 :
254 errmsg = cgen_parse_unsigned_integer (cd, strp, FR30_OPERAND_I8, (unsigned long *) (& fields->f_i8));
255 break;
256 case FR30_OPERAND_LABEL12 :
257 {
258 bfd_vma value = 0;
259 errmsg = cgen_parse_address (cd, strp, FR30_OPERAND_LABEL12, 0, NULL, & value);
260 fields->f_rel12 = value;
261 }
262 break;
263 case FR30_OPERAND_LABEL9 :
264 {
265 bfd_vma value = 0;
266 errmsg = cgen_parse_address (cd, strp, FR30_OPERAND_LABEL9, 0, NULL, & value);
267 fields->f_rel9 = value;
268 }
269 break;
270 case FR30_OPERAND_M4 :
271 errmsg = cgen_parse_signed_integer (cd, strp, FR30_OPERAND_M4, (long *) (& fields->f_m4));
272 break;
273 case FR30_OPERAND_PS :
274 errmsg = cgen_parse_keyword (cd, strp, & fr30_cgen_opval_h_ps, & junk);
275 break;
276 case FR30_OPERAND_REGLIST_HI_LD :
277 errmsg = parse_hi_register_list_ld (cd, strp, FR30_OPERAND_REGLIST_HI_LD, (unsigned long *) (& fields->f_reglist_hi_ld));
278 break;
279 case FR30_OPERAND_REGLIST_HI_ST :
280 errmsg = parse_hi_register_list_st (cd, strp, FR30_OPERAND_REGLIST_HI_ST, (unsigned long *) (& fields->f_reglist_hi_st));
281 break;
282 case FR30_OPERAND_REGLIST_LOW_LD :
283 errmsg = parse_low_register_list_ld (cd, strp, FR30_OPERAND_REGLIST_LOW_LD, (unsigned long *) (& fields->f_reglist_low_ld));
284 break;
285 case FR30_OPERAND_REGLIST_LOW_ST :
286 errmsg = parse_low_register_list_st (cd, strp, FR30_OPERAND_REGLIST_LOW_ST, (unsigned long *) (& fields->f_reglist_low_st));
287 break;
288 case FR30_OPERAND_S10 :
289 errmsg = cgen_parse_signed_integer (cd, strp, FR30_OPERAND_S10, (long *) (& fields->f_s10));
290 break;
291 case FR30_OPERAND_U10 :
292 errmsg = cgen_parse_unsigned_integer (cd, strp, FR30_OPERAND_U10, (unsigned long *) (& fields->f_u10));
293 break;
294 case FR30_OPERAND_U4 :
295 errmsg = cgen_parse_unsigned_integer (cd, strp, FR30_OPERAND_U4, (unsigned long *) (& fields->f_u4));
296 break;
297 case FR30_OPERAND_U4C :
298 errmsg = cgen_parse_unsigned_integer (cd, strp, FR30_OPERAND_U4C, (unsigned long *) (& fields->f_u4c));
299 break;
300 case FR30_OPERAND_U8 :
301 errmsg = cgen_parse_unsigned_integer (cd, strp, FR30_OPERAND_U8, (unsigned long *) (& fields->f_u8));
302 break;
303 case FR30_OPERAND_UDISP6 :
304 errmsg = cgen_parse_unsigned_integer (cd, strp, FR30_OPERAND_UDISP6, (unsigned long *) (& fields->f_udisp6));
305 break;
306
307 default :
308 /* xgettext:c-format */
309 fprintf (stderr, _("Unrecognized field %d while parsing.\n"), opindex);
310 abort ();
311 }
312
313 return errmsg;
314 }
315
316 cgen_parse_fn * const fr30_cgen_parse_handlers[] =
317 {
318 parse_insn_normal,
319 };
320
321 void
fr30_cgen_init_asm(CGEN_CPU_DESC cd)322 fr30_cgen_init_asm (CGEN_CPU_DESC cd)
323 {
324 fr30_cgen_init_opcode_table (cd);
325 fr30_cgen_init_ibld_table (cd);
326 cd->parse_handlers = & fr30_cgen_parse_handlers[0];
327 cd->parse_operand = fr30_cgen_parse_operand;
328 #ifdef CGEN_ASM_INIT_HOOK
329 CGEN_ASM_INIT_HOOK
330 #endif
331 }
332
333
334
335 /* Regex construction routine.
336
337 This translates an opcode syntax string into a regex string,
338 by replacing any non-character syntax element (such as an
339 opcode) with the pattern '.*'
340
341 It then compiles the regex and stores it in the opcode, for
342 later use by fr30_cgen_assemble_insn
343
344 Returns NULL for success, an error message for failure. */
345
346 char *
fr30_cgen_build_insn_regex(CGEN_INSN * insn)347 fr30_cgen_build_insn_regex (CGEN_INSN *insn)
348 {
349 CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn);
350 const char *mnem = CGEN_INSN_MNEMONIC (insn);
351 char rxbuf[CGEN_MAX_RX_ELEMENTS];
352 char *rx = rxbuf;
353 const CGEN_SYNTAX_CHAR_TYPE *syn;
354 int reg_err;
355
356 syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
357
358 /* Mnemonics come first in the syntax string. */
359 if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
360 return _("missing mnemonic in syntax string");
361 ++syn;
362
363 /* Generate a case sensitive regular expression that emulates case
364 insensitive matching in the "C" locale. We cannot generate a case
365 insensitive regular expression because in Turkish locales, 'i' and 'I'
366 are not equal modulo case conversion. */
367
368 /* Copy the literal mnemonic out of the insn. */
369 for (; *mnem; mnem++)
370 {
371 char c = *mnem;
372
373 if (ISALPHA (c))
374 {
375 *rx++ = '[';
376 *rx++ = TOLOWER (c);
377 *rx++ = TOUPPER (c);
378 *rx++ = ']';
379 }
380 else
381 *rx++ = c;
382 }
383
384 /* Copy any remaining literals from the syntax string into the rx. */
385 for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
386 {
387 if (CGEN_SYNTAX_CHAR_P (* syn))
388 {
389 char c = CGEN_SYNTAX_CHAR (* syn);
390
391 switch (c)
392 {
393 /* Escape any regex metacharacters in the syntax. */
394 case '.': case '[': case '\\':
395 case '*': case '^': case '$':
396
397 #ifdef CGEN_ESCAPE_EXTENDED_REGEX
398 case '?': case '{': case '}':
399 case '(': case ')': case '*':
400 case '|': case '+': case ']':
401 #endif
402 *rx++ = '\\';
403 *rx++ = c;
404 break;
405
406 default:
407 if (ISALPHA (c))
408 {
409 *rx++ = '[';
410 *rx++ = TOLOWER (c);
411 *rx++ = TOUPPER (c);
412 *rx++ = ']';
413 }
414 else
415 *rx++ = c;
416 break;
417 }
418 }
419 else
420 {
421 /* Replace non-syntax fields with globs. */
422 *rx++ = '.';
423 *rx++ = '*';
424 }
425 }
426
427 /* Trailing whitespace ok. */
428 * rx++ = '[';
429 * rx++ = ' ';
430 * rx++ = '\t';
431 * rx++ = ']';
432 * rx++ = '*';
433
434 /* But anchor it after that. */
435 * rx++ = '$';
436 * rx = '\0';
437
438 CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
439 reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);
440
441 if (reg_err == 0)
442 return NULL;
443 else
444 {
445 static char msg[80];
446
447 regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
448 regfree ((regex_t *) CGEN_INSN_RX (insn));
449 free (CGEN_INSN_RX (insn));
450 (CGEN_INSN_RX (insn)) = NULL;
451 return msg;
452 }
453 }
454
455
456 /* Default insn parser.
457
458 The syntax string is scanned and operands are parsed and stored in FIELDS.
459 Relocs are queued as we go via other callbacks.
460
461 ??? Note that this is currently an all-or-nothing parser. If we fail to
462 parse the instruction, we return 0 and the caller will start over from
463 the beginning. Backtracking will be necessary in parsing subexpressions,
464 but that can be handled there. Not handling backtracking here may get
465 expensive in the case of the m68k. Deal with later.
466
467 Returns NULL for success, an error message for failure. */
468
469 static const char *
parse_insn_normal(CGEN_CPU_DESC cd,const CGEN_INSN * insn,const char ** strp,CGEN_FIELDS * fields)470 parse_insn_normal (CGEN_CPU_DESC cd,
471 const CGEN_INSN *insn,
472 const char **strp,
473 CGEN_FIELDS *fields)
474 {
475 /* ??? Runtime added insns not handled yet. */
476 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
477 const char *str = *strp;
478 const char *errmsg;
479 const char *p;
480 const CGEN_SYNTAX_CHAR_TYPE * syn;
481 #ifdef CGEN_MNEMONIC_OPERANDS
482 /* FIXME: wip */
483 int past_opcode_p;
484 #endif
485
486 /* For now we assume the mnemonic is first (there are no leading operands).
487 We can parse it without needing to set up operand parsing.
488 GAS's input scrubber will ensure mnemonics are lowercase, but we may
489 not be called from GAS. */
490 p = CGEN_INSN_MNEMONIC (insn);
491 while (*p && TOLOWER (*p) == TOLOWER (*str))
492 ++p, ++str;
493
494 if (* p)
495 return _("unrecognized instruction");
496
497 #ifndef CGEN_MNEMONIC_OPERANDS
498 if (* str && ! ISSPACE (* str))
499 return _("unrecognized instruction");
500 #endif
501
502 CGEN_INIT_PARSE (cd);
503 cgen_init_parse_operand (cd);
504 #ifdef CGEN_MNEMONIC_OPERANDS
505 past_opcode_p = 0;
506 #endif
507
508 /* We don't check for (*str != '\0') here because we want to parse
509 any trailing fake arguments in the syntax string. */
510 syn = CGEN_SYNTAX_STRING (syntax);
511
512 /* Mnemonics come first for now, ensure valid string. */
513 if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
514 abort ();
515
516 ++syn;
517
518 while (* syn != 0)
519 {
520 /* Non operand chars must match exactly. */
521 if (CGEN_SYNTAX_CHAR_P (* syn))
522 {
523 /* FIXME: While we allow for non-GAS callers above, we assume the
524 first char after the mnemonic part is a space. */
525 /* FIXME: We also take inappropriate advantage of the fact that
526 GAS's input scrubber will remove extraneous blanks. */
527 if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
528 {
529 #ifdef CGEN_MNEMONIC_OPERANDS
530 if (CGEN_SYNTAX_CHAR(* syn) == ' ')
531 past_opcode_p = 1;
532 #endif
533 ++ syn;
534 ++ str;
535 }
536 else if (*str)
537 {
538 /* Syntax char didn't match. Can't be this insn. */
539 static char msg [80];
540
541 /* xgettext:c-format */
542 sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
543 CGEN_SYNTAX_CHAR(*syn), *str);
544 return msg;
545 }
546 else
547 {
548 /* Ran out of input. */
549 static char msg [80];
550
551 /* xgettext:c-format */
552 sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
553 CGEN_SYNTAX_CHAR(*syn));
554 return msg;
555 }
556 continue;
557 }
558
559 #ifdef CGEN_MNEMONIC_OPERANDS
560 (void) past_opcode_p;
561 #endif
562 /* We have an operand of some sort. */
563 errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
564 if (errmsg)
565 return errmsg;
566
567 /* Done with this operand, continue with next one. */
568 ++ syn;
569 }
570
571 /* If we're at the end of the syntax string, we're done. */
572 if (* syn == 0)
573 {
574 /* FIXME: For the moment we assume a valid `str' can only contain
575 blanks now. IE: We needn't try again with a longer version of
576 the insn and it is assumed that longer versions of insns appear
577 before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3). */
578 while (ISSPACE (* str))
579 ++ str;
580
581 if (* str != '\0')
582 return _("junk at end of line"); /* FIXME: would like to include `str' */
583
584 return NULL;
585 }
586
587 /* We couldn't parse it. */
588 return _("unrecognized instruction");
589 }
590
591 /* Main entry point.
592 This routine is called for each instruction to be assembled.
593 STR points to the insn to be assembled.
594 We assume all necessary tables have been initialized.
595 The assembled instruction, less any fixups, is stored in BUF.
596 Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
597 still needs to be converted to target byte order, otherwise BUF is an array
598 of bytes in target byte order.
599 The result is a pointer to the insn's entry in the opcode table,
600 or NULL if an error occured (an error message will have already been
601 printed).
602
603 Note that when processing (non-alias) macro-insns,
604 this function recurses.
605
606 ??? It's possible to make this cpu-independent.
607 One would have to deal with a few minor things.
608 At this point in time doing so would be more of a curiosity than useful
609 [for example this file isn't _that_ big], but keeping the possibility in
610 mind helps keep the design clean. */
611
612 const CGEN_INSN *
fr30_cgen_assemble_insn(CGEN_CPU_DESC cd,const char * str,CGEN_FIELDS * fields,CGEN_INSN_BYTES_PTR buf,char ** errmsg)613 fr30_cgen_assemble_insn (CGEN_CPU_DESC cd,
614 const char *str,
615 CGEN_FIELDS *fields,
616 CGEN_INSN_BYTES_PTR buf,
617 char **errmsg)
618 {
619 const char *start;
620 CGEN_INSN_LIST *ilist;
621 const char *parse_errmsg = NULL;
622 const char *insert_errmsg = NULL;
623 int recognized_mnemonic = 0;
624
625 /* Skip leading white space. */
626 while (ISSPACE (* str))
627 ++ str;
628
629 /* The instructions are stored in hashed lists.
630 Get the first in the list. */
631 ilist = CGEN_ASM_LOOKUP_INSN (cd, str);
632
633 /* Keep looking until we find a match. */
634 start = str;
635 for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
636 {
637 const CGEN_INSN *insn = ilist->insn;
638 recognized_mnemonic = 1;
639
640 #ifdef CGEN_VALIDATE_INSN_SUPPORTED
641 /* Not usually needed as unsupported opcodes
642 shouldn't be in the hash lists. */
643 /* Is this insn supported by the selected cpu? */
644 if (! fr30_cgen_insn_supported (cd, insn))
645 continue;
646 #endif
647 /* If the RELAXED attribute is set, this is an insn that shouldn't be
648 chosen immediately. Instead, it is used during assembler/linker
649 relaxation if possible. */
650 if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0)
651 continue;
652
653 str = start;
654
655 /* Skip this insn if str doesn't look right lexically. */
656 if (CGEN_INSN_RX (insn) != NULL &&
657 regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
658 continue;
659
660 /* Allow parse/insert handlers to obtain length of insn. */
661 CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
662
663 parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
664 if (parse_errmsg != NULL)
665 continue;
666
667 /* ??? 0 is passed for `pc'. */
668 insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
669 (bfd_vma) 0);
670 if (insert_errmsg != NULL)
671 continue;
672
673 /* It is up to the caller to actually output the insn and any
674 queued relocs. */
675 return insn;
676 }
677
678 {
679 static char errbuf[150];
680 const char *tmp_errmsg;
681 #ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
682 #define be_verbose 1
683 #else
684 #define be_verbose 0
685 #endif
686
687 if (be_verbose)
688 {
689 /* If requesting verbose error messages, use insert_errmsg.
690 Failing that, use parse_errmsg. */
691 tmp_errmsg = (insert_errmsg ? insert_errmsg :
692 parse_errmsg ? parse_errmsg :
693 recognized_mnemonic ?
694 _("unrecognized form of instruction") :
695 _("unrecognized instruction"));
696
697 if (strlen (start) > 50)
698 /* xgettext:c-format */
699 sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start);
700 else
701 /* xgettext:c-format */
702 sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start);
703 }
704 else
705 {
706 if (strlen (start) > 50)
707 /* xgettext:c-format */
708 sprintf (errbuf, _("bad instruction `%.50s...'"), start);
709 else
710 /* xgettext:c-format */
711 sprintf (errbuf, _("bad instruction `%.50s'"), start);
712 }
713
714 *errmsg = errbuf;
715 return NULL;
716 }
717 }
718