Copyright update for binutils
[external/binutils.git] / opcodes / lm32-asm.c
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-2016 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 "lm32-desc.h"
35 #include "lm32-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 \f
49 /* -- assembler routines inserted here.  */
50
51 /* -- asm.c */
52
53 /* Handle signed/unsigned literal.  */
54
55 static const char *
56 parse_imm (CGEN_CPU_DESC cd,
57            const char **strp,
58            int opindex,
59            unsigned long *valuep)
60 {
61   const char *errmsg;
62   signed long value;
63
64   errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);
65   if (errmsg == NULL)
66     {
67       unsigned long x = value & 0xFFFF0000;
68       if (x != 0 && x != 0xFFFF0000)
69         errmsg = _("immediate value out of range");
70       else
71         *valuep = (value & 0xFFFF);
72     }
73   return errmsg;
74 }
75
76 /* Handle hi() */
77
78 static const char *
79 parse_hi16 (CGEN_CPU_DESC cd,
80             const char **strp,
81             int opindex,
82             unsigned long *valuep)
83 {
84   if (strncasecmp (*strp, "hi(", 3) == 0)
85     {
86       enum cgen_parse_operand_result result_type;
87       bfd_vma value;
88       const char *errmsg;
89
90       *strp += 3;
91       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_HI16,
92                                    &result_type, &value);
93       if (**strp != ')')
94         return _("missing `)'");
95
96       ++*strp;
97       if (errmsg == NULL
98           && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
99         value = (value >> 16) & 0xffff;
100       *valuep = value;
101
102       return errmsg;
103     }
104
105   return parse_imm (cd, strp, opindex, valuep);
106 }
107
108 /* Handle lo() */
109
110 static const char *
111 parse_lo16 (CGEN_CPU_DESC cd,
112             const char **strp,
113             int opindex,
114             unsigned long *valuep)
115 {
116   if (strncasecmp (*strp, "lo(", 3) == 0)
117     {
118       const char *errmsg;
119       enum cgen_parse_operand_result result_type;
120       bfd_vma value;
121
122       *strp += 3;
123       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_LO16,
124                                    &result_type, &value);
125       if (**strp != ')')
126         return _("missing `)'");
127       ++*strp;
128       if (errmsg == NULL
129           && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
130         value &= 0xffff;
131       *valuep = value;
132       return errmsg;
133     }
134
135   return parse_imm (cd, strp, opindex, valuep);
136 }
137
138 /* Handle gp() */
139
140 static const char *
141 parse_gp16 (CGEN_CPU_DESC cd,
142             const char **strp,
143             int opindex,
144             long *valuep)
145 {
146   if (strncasecmp (*strp, "gp(", 3) == 0)
147     {
148       const char *errmsg;
149       enum cgen_parse_operand_result result_type;
150       bfd_vma value;
151
152       *strp += 3;
153       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_GPREL16,
154                                    & result_type, & value);
155       if (**strp != ')')
156         return _("missing `)'");
157       ++*strp;
158       if (errmsg == NULL
159           && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
160         value &= 0xffff;
161       *valuep = value;
162       return errmsg;
163     }
164
165   return _("expecting gp relative address: gp(symbol)");
166 }
167
168 /* Handle got() */
169
170 static const char *
171 parse_got16 (CGEN_CPU_DESC cd,
172              const char **strp,
173              int opindex,
174              long *valuep)
175 {
176   if (strncasecmp (*strp, "got(", 4) == 0)
177     {
178       const char *errmsg;
179       enum cgen_parse_operand_result result_type;
180       bfd_vma value;
181
182       *strp += 4;
183       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_LM32_16_GOT,
184                                    & result_type, & value);
185       if (**strp != ')')
186         return _("missing `)'");
187       ++*strp;
188       if (errmsg == NULL
189           && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
190         value &= 0xffff;
191       *valuep = value;
192       return errmsg;
193     }
194
195   return _("expecting got relative address: got(symbol)");
196 }
197
198 /* Handle gotoffhi16() */
199
200 static const char *
201 parse_gotoff_hi16 (CGEN_CPU_DESC cd,
202                    const char **strp,
203                    int opindex,
204                    long *valuep)
205 {
206   if (strncasecmp (*strp, "gotoffhi16(", 11) == 0)
207     {
208       const char *errmsg;
209       enum cgen_parse_operand_result result_type;
210       bfd_vma value;
211
212       *strp += 11;
213       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_LM32_GOTOFF_HI16,
214                                    & result_type, & value);
215       if (**strp != ')')
216         return _("missing `)'");
217       ++*strp;
218       if (errmsg == NULL
219           && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
220         value &= 0xffff;
221       *valuep = value;
222       return errmsg;
223     }
224
225   return _("expecting got relative address: gotoffhi16(symbol)");
226 }
227
228 /* Handle gotofflo16() */
229
230 static const char *
231 parse_gotoff_lo16 (CGEN_CPU_DESC cd,
232                    const char **strp,
233                    int opindex,
234                    long *valuep)
235 {
236   if (strncasecmp (*strp, "gotofflo16(", 11) == 0)
237     {
238       const char *errmsg;
239       enum cgen_parse_operand_result result_type;
240       bfd_vma value;
241
242       *strp += 11;
243       errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_LM32_GOTOFF_LO16,
244                                    &result_type, &value);
245       if (**strp != ')')
246         return _("missing `)'");
247       ++*strp;
248       if (errmsg == NULL
249           && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
250         value &= 0xffff;
251       *valuep = value;
252       return errmsg;
253     }
254
255   return _("expecting got relative address: gotofflo16(symbol)");
256 }
257
258 const char * lm32_cgen_parse_operand
259   (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);
260
261 /* Main entry point for operand parsing.
262
263    This function is basically just a big switch statement.  Earlier versions
264    used tables to look up the function to use, but
265    - if the table contains both assembler and disassembler functions then
266      the disassembler contains much of the assembler and vice-versa,
267    - there's a lot of inlining possibilities as things grow,
268    - using a switch statement avoids the function call overhead.
269
270    This function could be moved into `parse_insn_normal', but keeping it
271    separate makes clear the interface between `parse_insn_normal' and each of
272    the handlers.  */
273
274 const char *
275 lm32_cgen_parse_operand (CGEN_CPU_DESC cd,
276                            int opindex,
277                            const char ** strp,
278                            CGEN_FIELDS * fields)
279 {
280   const char * errmsg = NULL;
281   /* Used by scalar operands that still need to be parsed.  */
282   long junk ATTRIBUTE_UNUSED;
283
284   switch (opindex)
285     {
286     case LM32_OPERAND_BRANCH :
287       {
288         bfd_vma value = 0;
289         errmsg = cgen_parse_address (cd, strp, LM32_OPERAND_BRANCH, 0, NULL,  & value);
290         fields->f_branch = value;
291       }
292       break;
293     case LM32_OPERAND_CALL :
294       {
295         bfd_vma value = 0;
296         errmsg = cgen_parse_address (cd, strp, LM32_OPERAND_CALL, 0, NULL,  & value);
297         fields->f_call = value;
298       }
299       break;
300     case LM32_OPERAND_CSR :
301       errmsg = cgen_parse_keyword (cd, strp, & lm32_cgen_opval_h_csr, & fields->f_csr);
302       break;
303     case LM32_OPERAND_EXCEPTION :
304       errmsg = cgen_parse_unsigned_integer (cd, strp, LM32_OPERAND_EXCEPTION, (unsigned long *) (& fields->f_exception));
305       break;
306     case LM32_OPERAND_GOT16 :
307       errmsg = parse_got16 (cd, strp, LM32_OPERAND_GOT16, (long *) (& fields->f_imm));
308       break;
309     case LM32_OPERAND_GOTOFFHI16 :
310       errmsg = parse_gotoff_hi16 (cd, strp, LM32_OPERAND_GOTOFFHI16, (long *) (& fields->f_imm));
311       break;
312     case LM32_OPERAND_GOTOFFLO16 :
313       errmsg = parse_gotoff_lo16 (cd, strp, LM32_OPERAND_GOTOFFLO16, (long *) (& fields->f_imm));
314       break;
315     case LM32_OPERAND_GP16 :
316       errmsg = parse_gp16 (cd, strp, LM32_OPERAND_GP16, (long *) (& fields->f_imm));
317       break;
318     case LM32_OPERAND_HI16 :
319       errmsg = parse_hi16 (cd, strp, LM32_OPERAND_HI16, (unsigned long *) (& fields->f_uimm));
320       break;
321     case LM32_OPERAND_IMM :
322       errmsg = cgen_parse_signed_integer (cd, strp, LM32_OPERAND_IMM, (long *) (& fields->f_imm));
323       break;
324     case LM32_OPERAND_LO16 :
325       errmsg = parse_lo16 (cd, strp, LM32_OPERAND_LO16, (unsigned long *) (& fields->f_uimm));
326       break;
327     case LM32_OPERAND_R0 :
328       errmsg = cgen_parse_keyword (cd, strp, & lm32_cgen_opval_h_gr, & fields->f_r0);
329       break;
330     case LM32_OPERAND_R1 :
331       errmsg = cgen_parse_keyword (cd, strp, & lm32_cgen_opval_h_gr, & fields->f_r1);
332       break;
333     case LM32_OPERAND_R2 :
334       errmsg = cgen_parse_keyword (cd, strp, & lm32_cgen_opval_h_gr, & fields->f_r2);
335       break;
336     case LM32_OPERAND_SHIFT :
337       errmsg = cgen_parse_unsigned_integer (cd, strp, LM32_OPERAND_SHIFT, (unsigned long *) (& fields->f_shift));
338       break;
339     case LM32_OPERAND_UIMM :
340       errmsg = cgen_parse_unsigned_integer (cd, strp, LM32_OPERAND_UIMM, (unsigned long *) (& fields->f_uimm));
341       break;
342     case LM32_OPERAND_USER :
343       errmsg = cgen_parse_unsigned_integer (cd, strp, LM32_OPERAND_USER, (unsigned long *) (& fields->f_user));
344       break;
345
346     default :
347       /* xgettext:c-format */
348       fprintf (stderr, _("Unrecognized field %d while parsing.\n"), opindex);
349       abort ();
350   }
351
352   return errmsg;
353 }
354
355 cgen_parse_fn * const lm32_cgen_parse_handlers[] =
356 {
357   parse_insn_normal,
358 };
359
360 void
361 lm32_cgen_init_asm (CGEN_CPU_DESC cd)
362 {
363   lm32_cgen_init_opcode_table (cd);
364   lm32_cgen_init_ibld_table (cd);
365   cd->parse_handlers = & lm32_cgen_parse_handlers[0];
366   cd->parse_operand = lm32_cgen_parse_operand;
367 #ifdef CGEN_ASM_INIT_HOOK
368 CGEN_ASM_INIT_HOOK
369 #endif
370 }
371
372 \f
373
374 /* Regex construction routine.
375
376    This translates an opcode syntax string into a regex string,
377    by replacing any non-character syntax element (such as an
378    opcode) with the pattern '.*'
379
380    It then compiles the regex and stores it in the opcode, for
381    later use by lm32_cgen_assemble_insn
382
383    Returns NULL for success, an error message for failure.  */
384
385 char *
386 lm32_cgen_build_insn_regex (CGEN_INSN *insn)
387 {
388   CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn);
389   const char *mnem = CGEN_INSN_MNEMONIC (insn);
390   char rxbuf[CGEN_MAX_RX_ELEMENTS];
391   char *rx = rxbuf;
392   const CGEN_SYNTAX_CHAR_TYPE *syn;
393   int reg_err;
394
395   syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
396
397   /* Mnemonics come first in the syntax string.  */
398   if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
399     return _("missing mnemonic in syntax string");
400   ++syn;
401
402   /* Generate a case sensitive regular expression that emulates case
403      insensitive matching in the "C" locale.  We cannot generate a case
404      insensitive regular expression because in Turkish locales, 'i' and 'I'
405      are not equal modulo case conversion.  */
406
407   /* Copy the literal mnemonic out of the insn.  */
408   for (; *mnem; mnem++)
409     {
410       char c = *mnem;
411
412       if (ISALPHA (c))
413         {
414           *rx++ = '[';
415           *rx++ = TOLOWER (c);
416           *rx++ = TOUPPER (c);
417           *rx++ = ']';
418         }
419       else
420         *rx++ = c;
421     }
422
423   /* Copy any remaining literals from the syntax string into the rx.  */
424   for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
425     {
426       if (CGEN_SYNTAX_CHAR_P (* syn))
427         {
428           char c = CGEN_SYNTAX_CHAR (* syn);
429
430           switch (c)
431             {
432               /* Escape any regex metacharacters in the syntax.  */
433             case '.': case '[': case '\\':
434             case '*': case '^': case '$':
435
436 #ifdef CGEN_ESCAPE_EXTENDED_REGEX
437             case '?': case '{': case '}':
438             case '(': case ')': case '*':
439             case '|': case '+': case ']':
440 #endif
441               *rx++ = '\\';
442               *rx++ = c;
443               break;
444
445             default:
446               if (ISALPHA (c))
447                 {
448                   *rx++ = '[';
449                   *rx++ = TOLOWER (c);
450                   *rx++ = TOUPPER (c);
451                   *rx++ = ']';
452                 }
453               else
454                 *rx++ = c;
455               break;
456             }
457         }
458       else
459         {
460           /* Replace non-syntax fields with globs.  */
461           *rx++ = '.';
462           *rx++ = '*';
463         }
464     }
465
466   /* Trailing whitespace ok.  */
467   * rx++ = '[';
468   * rx++ = ' ';
469   * rx++ = '\t';
470   * rx++ = ']';
471   * rx++ = '*';
472
473   /* But anchor it after that.  */
474   * rx++ = '$';
475   * rx = '\0';
476
477   CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
478   reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);
479
480   if (reg_err == 0)
481     return NULL;
482   else
483     {
484       static char msg[80];
485
486       regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
487       regfree ((regex_t *) CGEN_INSN_RX (insn));
488       free (CGEN_INSN_RX (insn));
489       (CGEN_INSN_RX (insn)) = NULL;
490       return msg;
491     }
492 }
493
494 \f
495 /* Default insn parser.
496
497    The syntax string is scanned and operands are parsed and stored in FIELDS.
498    Relocs are queued as we go via other callbacks.
499
500    ??? Note that this is currently an all-or-nothing parser.  If we fail to
501    parse the instruction, we return 0 and the caller will start over from
502    the beginning.  Backtracking will be necessary in parsing subexpressions,
503    but that can be handled there.  Not handling backtracking here may get
504    expensive in the case of the m68k.  Deal with later.
505
506    Returns NULL for success, an error message for failure.  */
507
508 static const char *
509 parse_insn_normal (CGEN_CPU_DESC cd,
510                    const CGEN_INSN *insn,
511                    const char **strp,
512                    CGEN_FIELDS *fields)
513 {
514   /* ??? Runtime added insns not handled yet.  */
515   const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
516   const char *str = *strp;
517   const char *errmsg;
518   const char *p;
519   const CGEN_SYNTAX_CHAR_TYPE * syn;
520 #ifdef CGEN_MNEMONIC_OPERANDS
521   /* FIXME: wip */
522   int past_opcode_p;
523 #endif
524
525   /* For now we assume the mnemonic is first (there are no leading operands).
526      We can parse it without needing to set up operand parsing.
527      GAS's input scrubber will ensure mnemonics are lowercase, but we may
528      not be called from GAS.  */
529   p = CGEN_INSN_MNEMONIC (insn);
530   while (*p && TOLOWER (*p) == TOLOWER (*str))
531     ++p, ++str;
532
533   if (* p)
534     return _("unrecognized instruction");
535
536 #ifndef CGEN_MNEMONIC_OPERANDS
537   if (* str && ! ISSPACE (* str))
538     return _("unrecognized instruction");
539 #endif
540
541   CGEN_INIT_PARSE (cd);
542   cgen_init_parse_operand (cd);
543 #ifdef CGEN_MNEMONIC_OPERANDS
544   past_opcode_p = 0;
545 #endif
546
547   /* We don't check for (*str != '\0') here because we want to parse
548      any trailing fake arguments in the syntax string.  */
549   syn = CGEN_SYNTAX_STRING (syntax);
550
551   /* Mnemonics come first for now, ensure valid string.  */
552   if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
553     abort ();
554
555   ++syn;
556
557   while (* syn != 0)
558     {
559       /* Non operand chars must match exactly.  */
560       if (CGEN_SYNTAX_CHAR_P (* syn))
561         {
562           /* FIXME: While we allow for non-GAS callers above, we assume the
563              first char after the mnemonic part is a space.  */
564           /* FIXME: We also take inappropriate advantage of the fact that
565              GAS's input scrubber will remove extraneous blanks.  */
566           if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
567             {
568 #ifdef CGEN_MNEMONIC_OPERANDS
569               if (CGEN_SYNTAX_CHAR(* syn) == ' ')
570                 past_opcode_p = 1;
571 #endif
572               ++ syn;
573               ++ str;
574             }
575           else if (*str)
576             {
577               /* Syntax char didn't match.  Can't be this insn.  */
578               static char msg [80];
579
580               /* xgettext:c-format */
581               sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
582                        CGEN_SYNTAX_CHAR(*syn), *str);
583               return msg;
584             }
585           else
586             {
587               /* Ran out of input.  */
588               static char msg [80];
589
590               /* xgettext:c-format */
591               sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
592                        CGEN_SYNTAX_CHAR(*syn));
593               return msg;
594             }
595           continue;
596         }
597
598 #ifdef CGEN_MNEMONIC_OPERANDS
599       (void) past_opcode_p;
600 #endif
601       /* We have an operand of some sort.  */
602       errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
603       if (errmsg)
604         return errmsg;
605
606       /* Done with this operand, continue with next one.  */
607       ++ syn;
608     }
609
610   /* If we're at the end of the syntax string, we're done.  */
611   if (* syn == 0)
612     {
613       /* FIXME: For the moment we assume a valid `str' can only contain
614          blanks now.  IE: We needn't try again with a longer version of
615          the insn and it is assumed that longer versions of insns appear
616          before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3).  */
617       while (ISSPACE (* str))
618         ++ str;
619
620       if (* str != '\0')
621         return _("junk at end of line"); /* FIXME: would like to include `str' */
622
623       return NULL;
624     }
625
626   /* We couldn't parse it.  */
627   return _("unrecognized instruction");
628 }
629 \f
630 /* Main entry point.
631    This routine is called for each instruction to be assembled.
632    STR points to the insn to be assembled.
633    We assume all necessary tables have been initialized.
634    The assembled instruction, less any fixups, is stored in BUF.
635    Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
636    still needs to be converted to target byte order, otherwise BUF is an array
637    of bytes in target byte order.
638    The result is a pointer to the insn's entry in the opcode table,
639    or NULL if an error occured (an error message will have already been
640    printed).
641
642    Note that when processing (non-alias) macro-insns,
643    this function recurses.
644
645    ??? It's possible to make this cpu-independent.
646    One would have to deal with a few minor things.
647    At this point in time doing so would be more of a curiosity than useful
648    [for example this file isn't _that_ big], but keeping the possibility in
649    mind helps keep the design clean.  */
650
651 const CGEN_INSN *
652 lm32_cgen_assemble_insn (CGEN_CPU_DESC cd,
653                            const char *str,
654                            CGEN_FIELDS *fields,
655                            CGEN_INSN_BYTES_PTR buf,
656                            char **errmsg)
657 {
658   const char *start;
659   CGEN_INSN_LIST *ilist;
660   const char *parse_errmsg = NULL;
661   const char *insert_errmsg = NULL;
662   int recognized_mnemonic = 0;
663
664   /* Skip leading white space.  */
665   while (ISSPACE (* str))
666     ++ str;
667
668   /* The instructions are stored in hashed lists.
669      Get the first in the list.  */
670   ilist = CGEN_ASM_LOOKUP_INSN (cd, str);
671
672   /* Keep looking until we find a match.  */
673   start = str;
674   for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
675     {
676       const CGEN_INSN *insn = ilist->insn;
677       recognized_mnemonic = 1;
678
679 #ifdef CGEN_VALIDATE_INSN_SUPPORTED
680       /* Not usually needed as unsupported opcodes
681          shouldn't be in the hash lists.  */
682       /* Is this insn supported by the selected cpu?  */
683       if (! lm32_cgen_insn_supported (cd, insn))
684         continue;
685 #endif
686       /* If the RELAXED attribute is set, this is an insn that shouldn't be
687          chosen immediately.  Instead, it is used during assembler/linker
688          relaxation if possible.  */
689       if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0)
690         continue;
691
692       str = start;
693
694       /* Skip this insn if str doesn't look right lexically.  */
695       if (CGEN_INSN_RX (insn) != NULL &&
696           regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
697         continue;
698
699       /* Allow parse/insert handlers to obtain length of insn.  */
700       CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
701
702       parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
703       if (parse_errmsg != NULL)
704         continue;
705
706       /* ??? 0 is passed for `pc'.  */
707       insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
708                                                  (bfd_vma) 0);
709       if (insert_errmsg != NULL)
710         continue;
711
712       /* It is up to the caller to actually output the insn and any
713          queued relocs.  */
714       return insn;
715     }
716
717   {
718     static char errbuf[150];
719     const char *tmp_errmsg;
720 #ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
721 #define be_verbose 1
722 #else
723 #define be_verbose 0
724 #endif
725
726     if (be_verbose)
727       {
728         /* If requesting verbose error messages, use insert_errmsg.
729            Failing that, use parse_errmsg.  */
730         tmp_errmsg = (insert_errmsg ? insert_errmsg :
731                       parse_errmsg ? parse_errmsg :
732                       recognized_mnemonic ?
733                       _("unrecognized form of instruction") :
734                       _("unrecognized instruction"));
735
736         if (strlen (start) > 50)
737           /* xgettext:c-format */
738           sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start);
739         else
740           /* xgettext:c-format */
741           sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start);
742       }
743     else
744       {
745         if (strlen (start) > 50)
746           /* xgettext:c-format */
747           sprintf (errbuf, _("bad instruction `%.50s...'"), start);
748         else
749           /* xgettext:c-format */
750           sprintf (errbuf, _("bad instruction `%.50s'"), start);
751       }
752
753     *errmsg = errbuf;
754     return NULL;
755   }
756 }