1 /* Assembler interface for targets using CGEN. -*- C -*-
2 CGEN: Cpu tools GENerator
4 THIS FILE IS MACHINE GENERATED WITH CGEN.
5 - the resultant file is machine generated, cgen-asm.in isn't
7 Copyright 1996-2014 Free Software Foundation, Inc.
9 This file is part of libopcodes.
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)
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.
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. */
26 /* ??? Eventually more and more of this stuff can go to cpu-independent files.
34 #include "or1k-desc.h"
38 #include "libiberty.h"
39 #include "safe-ctype.h"
42 #define min(a,b) ((a) < (b) ? (a) : (b))
44 #define max(a,b) ((a) > (b) ? (a) : (b))
46 static const char * parse_insn_normal
47 (CGEN_CPU_DESC
, const CGEN_INSN
*, const char **, CGEN_FIELDS
*);
49 /* -- assembler routines inserted here. */
53 static const char * MISSING_CLOSING_PARENTHESIS
= N_("missing `)'");
55 #define CGEN_VERBOSE_ASSEMBLER_ERRORS
58 parse_disp26 (CGEN_CPU_DESC cd
,
62 enum cgen_parse_operand_result
* resultp
,
65 const char *errmsg
= NULL
;
66 enum cgen_parse_operand_result result_type
;
68 if (strncasecmp (*strp
, "plt(", 4) == 0)
73 errmsg
= cgen_parse_address (cd
, strp
, opindex
, BFD_RELOC_OR1K_PLT26
,
74 & result_type
, & value
);
76 return MISSING_CLOSING_PARENTHESIS
;
79 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
80 value
= (value
>> 2) & 0xffff;
84 return cgen_parse_address (cd
, strp
, opindex
, opinfo
, resultp
, valuep
);
88 parse_simm16 (CGEN_CPU_DESC cd
, const char ** strp
, int opindex
, long * valuep
)
91 enum cgen_parse_operand_result result_type
;
97 if (strncasecmp (*strp
, "hi(", 3) == 0)
102 errmsg
= cgen_parse_address (cd
, strp
, opindex
, BFD_RELOC_HI16
,
103 & result_type
, & value
);
105 errmsg
= MISSING_CLOSING_PARENTHESIS
;
111 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
115 ret
= (ret
^ 0x8000) - 0x8000;
118 else if (strncasecmp (*strp
, "lo(", 3) == 0)
123 errmsg
= cgen_parse_address (cd
, strp
, opindex
, BFD_RELOC_LO16
,
124 & result_type
, & value
);
126 return MISSING_CLOSING_PARENTHESIS
;
131 if (result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
134 ret
= (ret
^ 0x8000) - 0x8000;
137 else if (strncasecmp (*strp
, "got(", 4) == 0)
142 errmsg
= cgen_parse_address (cd
, strp
, opindex
, BFD_RELOC_OR1K_GOT16
,
143 & result_type
, & value
);
145 return MISSING_CLOSING_PARENTHESIS
;
148 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
153 else if (strncasecmp (*strp
, "gotpchi(", 8) == 0)
158 errmsg
= cgen_parse_address (cd
, strp
, opindex
,
159 BFD_RELOC_OR1K_GOTPC_HI16
,
160 & result_type
, & value
);
162 return MISSING_CLOSING_PARENTHESIS
;
165 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
166 value
= (value
>> 16) & 0xffff;
170 else if (strncasecmp (*strp
, "gotpclo(", 8) == 0)
175 errmsg
= cgen_parse_address (cd
, strp
, opindex
,
176 BFD_RELOC_OR1K_GOTPC_LO16
,
177 &result_type
, &value
);
179 return MISSING_CLOSING_PARENTHESIS
;
182 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
187 else if (strncasecmp (*strp
, "gotoffhi(", 9) == 0)
192 errmsg
= cgen_parse_address (cd
, strp
, opindex
,
193 BFD_RELOC_OR1K_GOTOFF_HI16
,
194 & result_type
, & value
);
197 return MISSING_CLOSING_PARENTHESIS
;
200 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
201 value
= (value
>> 16) & 0xffff;
205 else if (strncasecmp (*strp
, "gotofflo(", 9) == 0)
210 errmsg
= cgen_parse_address (cd
, strp
, opindex
,
211 BFD_RELOC_OR1K_GOTOFF_LO16
,
212 &result_type
, &value
);
214 return MISSING_CLOSING_PARENTHESIS
;
217 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
222 else if (strncasecmp (*strp
, "tlsgdhi(", 8) == 0)
227 errmsg
= cgen_parse_address (cd
, strp
, opindex
,
228 BFD_RELOC_OR1K_TLS_GD_HI16
,
229 & result_type
, & value
);
232 return MISSING_CLOSING_PARENTHESIS
;
235 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
236 value
= (value
>> 16) & 0xffff;
240 else if (strncasecmp (*strp
, "tlsgdlo(", 8) == 0)
245 errmsg
= cgen_parse_address (cd
, strp
, opindex
,
246 BFD_RELOC_OR1K_TLS_GD_LO16
,
247 &result_type
, &value
);
249 return MISSING_CLOSING_PARENTHESIS
;
252 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
257 else if (strncasecmp (*strp
, "tlsldmhi(", 9) == 0)
262 errmsg
= cgen_parse_address (cd
, strp
, opindex
,
263 BFD_RELOC_OR1K_TLS_LDM_HI16
,
264 & result_type
, & value
);
267 return MISSING_CLOSING_PARENTHESIS
;
270 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
271 value
= (value
>> 16) & 0xffff;
275 else if (strncasecmp (*strp
, "tlsldmlo(", 9) == 0)
280 errmsg
= cgen_parse_address (cd
, strp
, opindex
,
281 BFD_RELOC_OR1K_TLS_LDM_LO16
,
282 &result_type
, &value
);
284 return MISSING_CLOSING_PARENTHESIS
;
287 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
292 else if (strncasecmp (*strp
, "dtpoffhi(", 9) == 0)
297 errmsg
= cgen_parse_address (cd
, strp
, opindex
,
298 BFD_RELOC_OR1K_TLS_LDO_HI16
,
299 & result_type
, & value
);
302 return MISSING_CLOSING_PARENTHESIS
;
305 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
306 value
= (value
>> 16) & 0xffff;
310 else if (strncasecmp (*strp
, "dtpofflo(", 9) == 0)
315 errmsg
= cgen_parse_address (cd
, strp
, opindex
,
316 BFD_RELOC_OR1K_TLS_LDO_LO16
,
317 &result_type
, &value
);
319 return MISSING_CLOSING_PARENTHESIS
;
322 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
327 else if (strncasecmp (*strp
, "gottpoffhi(", 11) == 0)
332 errmsg
= cgen_parse_address (cd
, strp
, opindex
,
333 BFD_RELOC_OR1K_TLS_IE_HI16
,
334 & result_type
, & value
);
337 return MISSING_CLOSING_PARENTHESIS
;
340 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
341 value
= (value
>> 16) & 0xffff;
345 else if (strncasecmp (*strp
, "gottpofflo(", 11) == 0)
350 errmsg
= cgen_parse_address (cd
, strp
, opindex
,
351 BFD_RELOC_OR1K_TLS_IE_LO16
,
352 &result_type
, &value
);
354 return MISSING_CLOSING_PARENTHESIS
;
357 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
362 else if (strncasecmp (*strp
, "tpoffhi(", 8) == 0)
367 errmsg
= cgen_parse_address (cd
, strp
, opindex
,
368 BFD_RELOC_OR1K_TLS_LE_HI16
,
369 & result_type
, & value
);
372 return MISSING_CLOSING_PARENTHESIS
;
375 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
376 value
= (value
>> 16) & 0xffff;
380 else if (strncasecmp (*strp
, "tpofflo(", 8) == 0)
385 errmsg
= cgen_parse_address (cd
, strp
, opindex
,
386 BFD_RELOC_OR1K_TLS_LE_LO16
,
387 &result_type
, &value
);
389 return MISSING_CLOSING_PARENTHESIS
;
392 && result_type
== CGEN_PARSE_OPERAND_RESULT_NUMBER
)
400 errmsg
= cgen_parse_signed_integer (cd
, strp
, opindex
, &value
);
411 parse_uimm16 (CGEN_CPU_DESC cd
, const char ** strp
, int opindex
, unsigned long * valuep
)
413 const char *errmsg
= parse_simm16(cd
, strp
, opindex
, (long *) valuep
);
421 const char * or1k_cgen_parse_operand
422 (CGEN_CPU_DESC
, int, const char **, CGEN_FIELDS
*);
424 /* Main entry point for operand parsing.
426 This function is basically just a big switch statement. Earlier versions
427 used tables to look up the function to use, but
428 - if the table contains both assembler and disassembler functions then
429 the disassembler contains much of the assembler and vice-versa,
430 - there's a lot of inlining possibilities as things grow,
431 - using a switch statement avoids the function call overhead.
433 This function could be moved into `parse_insn_normal', but keeping it
434 separate makes clear the interface between `parse_insn_normal' and each of
438 or1k_cgen_parse_operand (CGEN_CPU_DESC cd
,
441 CGEN_FIELDS
* fields
)
443 const char * errmsg
= NULL
;
444 /* Used by scalar operands that still need to be parsed. */
445 long junk ATTRIBUTE_UNUSED
;
449 case OR1K_OPERAND_DISP26
:
452 errmsg
= parse_disp26 (cd
, strp
, OR1K_OPERAND_DISP26
, 0, NULL
, & value
);
453 fields
->f_disp26
= value
;
456 case OR1K_OPERAND_RA
:
457 errmsg
= cgen_parse_keyword (cd
, strp
, & or1k_cgen_opval_h_gpr
, & fields
->f_r2
);
459 case OR1K_OPERAND_RADF
:
460 errmsg
= cgen_parse_keyword (cd
, strp
, & or1k_cgen_opval_h_fdr
, & fields
->f_r1
);
462 case OR1K_OPERAND_RASF
:
463 errmsg
= cgen_parse_keyword (cd
, strp
, & or1k_cgen_opval_h_fsr
, & fields
->f_r2
);
465 case OR1K_OPERAND_RB
:
466 errmsg
= cgen_parse_keyword (cd
, strp
, & or1k_cgen_opval_h_gpr
, & fields
->f_r3
);
468 case OR1K_OPERAND_RBDF
:
469 errmsg
= cgen_parse_keyword (cd
, strp
, & or1k_cgen_opval_h_fdr
, & fields
->f_r1
);
471 case OR1K_OPERAND_RBSF
:
472 errmsg
= cgen_parse_keyword (cd
, strp
, & or1k_cgen_opval_h_fsr
, & fields
->f_r3
);
474 case OR1K_OPERAND_RD
:
475 errmsg
= cgen_parse_keyword (cd
, strp
, & or1k_cgen_opval_h_gpr
, & fields
->f_r1
);
477 case OR1K_OPERAND_RDDF
:
478 errmsg
= cgen_parse_keyword (cd
, strp
, & or1k_cgen_opval_h_fdr
, & fields
->f_r1
);
480 case OR1K_OPERAND_RDSF
:
481 errmsg
= cgen_parse_keyword (cd
, strp
, & or1k_cgen_opval_h_fsr
, & fields
->f_r1
);
483 case OR1K_OPERAND_SIMM16
:
484 errmsg
= parse_simm16 (cd
, strp
, OR1K_OPERAND_SIMM16
, (long *) (& fields
->f_simm16
));
486 case OR1K_OPERAND_SIMM16_SPLIT
:
487 errmsg
= parse_simm16 (cd
, strp
, OR1K_OPERAND_SIMM16_SPLIT
, (long *) (& fields
->f_simm16_split
));
489 case OR1K_OPERAND_UIMM16
:
490 errmsg
= parse_uimm16 (cd
, strp
, OR1K_OPERAND_UIMM16
, (unsigned long *) (& fields
->f_uimm16
));
492 case OR1K_OPERAND_UIMM16_SPLIT
:
493 errmsg
= parse_uimm16 (cd
, strp
, OR1K_OPERAND_UIMM16_SPLIT
, (unsigned long *) (& fields
->f_uimm16_split
));
495 case OR1K_OPERAND_UIMM6
:
496 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, OR1K_OPERAND_UIMM6
, (unsigned long *) (& fields
->f_uimm6
));
500 /* xgettext:c-format */
501 fprintf (stderr
, _("Unrecognized field %d while parsing.\n"), opindex
);
508 cgen_parse_fn
* const or1k_cgen_parse_handlers
[] =
514 or1k_cgen_init_asm (CGEN_CPU_DESC cd
)
516 or1k_cgen_init_opcode_table (cd
);
517 or1k_cgen_init_ibld_table (cd
);
518 cd
->parse_handlers
= & or1k_cgen_parse_handlers
[0];
519 cd
->parse_operand
= or1k_cgen_parse_operand
;
520 #ifdef CGEN_ASM_INIT_HOOK
527 /* Regex construction routine.
529 This translates an opcode syntax string into a regex string,
530 by replacing any non-character syntax element (such as an
531 opcode) with the pattern '.*'
533 It then compiles the regex and stores it in the opcode, for
534 later use by or1k_cgen_assemble_insn
536 Returns NULL for success, an error message for failure. */
539 or1k_cgen_build_insn_regex (CGEN_INSN
*insn
)
541 CGEN_OPCODE
*opc
= (CGEN_OPCODE
*) CGEN_INSN_OPCODE (insn
);
542 const char *mnem
= CGEN_INSN_MNEMONIC (insn
);
543 char rxbuf
[CGEN_MAX_RX_ELEMENTS
];
545 const CGEN_SYNTAX_CHAR_TYPE
*syn
;
548 syn
= CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc
));
550 /* Mnemonics come first in the syntax string. */
551 if (! CGEN_SYNTAX_MNEMONIC_P (* syn
))
552 return _("missing mnemonic in syntax string");
555 /* Generate a case sensitive regular expression that emulates case
556 insensitive matching in the "C" locale. We cannot generate a case
557 insensitive regular expression because in Turkish locales, 'i' and 'I'
558 are not equal modulo case conversion. */
560 /* Copy the literal mnemonic out of the insn. */
561 for (; *mnem
; mnem
++)
576 /* Copy any remaining literals from the syntax string into the rx. */
577 for(; * syn
!= 0 && rx
<= rxbuf
+ (CGEN_MAX_RX_ELEMENTS
- 7 - 4); ++syn
)
579 if (CGEN_SYNTAX_CHAR_P (* syn
))
581 char c
= CGEN_SYNTAX_CHAR (* syn
);
585 /* Escape any regex metacharacters in the syntax. */
586 case '.': case '[': case '\\':
587 case '*': case '^': case '$':
589 #ifdef CGEN_ESCAPE_EXTENDED_REGEX
590 case '?': case '{': case '}':
591 case '(': case ')': case '*':
592 case '|': case '+': case ']':
613 /* Replace non-syntax fields with globs. */
619 /* Trailing whitespace ok. */
626 /* But anchor it after that. */
630 CGEN_INSN_RX (insn
) = xmalloc (sizeof (regex_t
));
631 reg_err
= regcomp ((regex_t
*) CGEN_INSN_RX (insn
), rxbuf
, REG_NOSUB
);
639 regerror (reg_err
, (regex_t
*) CGEN_INSN_RX (insn
), msg
, 80);
640 regfree ((regex_t
*) CGEN_INSN_RX (insn
));
641 free (CGEN_INSN_RX (insn
));
642 (CGEN_INSN_RX (insn
)) = NULL
;
648 /* Default insn parser.
650 The syntax string is scanned and operands are parsed and stored in FIELDS.
651 Relocs are queued as we go via other callbacks.
653 ??? Note that this is currently an all-or-nothing parser. If we fail to
654 parse the instruction, we return 0 and the caller will start over from
655 the beginning. Backtracking will be necessary in parsing subexpressions,
656 but that can be handled there. Not handling backtracking here may get
657 expensive in the case of the m68k. Deal with later.
659 Returns NULL for success, an error message for failure. */
662 parse_insn_normal (CGEN_CPU_DESC cd
,
663 const CGEN_INSN
*insn
,
667 /* ??? Runtime added insns not handled yet. */
668 const CGEN_SYNTAX
*syntax
= CGEN_INSN_SYNTAX (insn
);
669 const char *str
= *strp
;
672 const CGEN_SYNTAX_CHAR_TYPE
* syn
;
673 #ifdef CGEN_MNEMONIC_OPERANDS
678 /* For now we assume the mnemonic is first (there are no leading operands).
679 We can parse it without needing to set up operand parsing.
680 GAS's input scrubber will ensure mnemonics are lowercase, but we may
681 not be called from GAS. */
682 p
= CGEN_INSN_MNEMONIC (insn
);
683 while (*p
&& TOLOWER (*p
) == TOLOWER (*str
))
687 return _("unrecognized instruction");
689 #ifndef CGEN_MNEMONIC_OPERANDS
690 if (* str
&& ! ISSPACE (* str
))
691 return _("unrecognized instruction");
694 CGEN_INIT_PARSE (cd
);
695 cgen_init_parse_operand (cd
);
696 #ifdef CGEN_MNEMONIC_OPERANDS
700 /* We don't check for (*str != '\0') here because we want to parse
701 any trailing fake arguments in the syntax string. */
702 syn
= CGEN_SYNTAX_STRING (syntax
);
704 /* Mnemonics come first for now, ensure valid string. */
705 if (! CGEN_SYNTAX_MNEMONIC_P (* syn
))
712 /* Non operand chars must match exactly. */
713 if (CGEN_SYNTAX_CHAR_P (* syn
))
715 /* FIXME: While we allow for non-GAS callers above, we assume the
716 first char after the mnemonic part is a space. */
717 /* FIXME: We also take inappropriate advantage of the fact that
718 GAS's input scrubber will remove extraneous blanks. */
719 if (TOLOWER (*str
) == TOLOWER (CGEN_SYNTAX_CHAR (* syn
)))
721 #ifdef CGEN_MNEMONIC_OPERANDS
722 if (CGEN_SYNTAX_CHAR(* syn
) == ' ')
730 /* Syntax char didn't match. Can't be this insn. */
731 static char msg
[80];
733 /* xgettext:c-format */
734 sprintf (msg
, _("syntax error (expected char `%c', found `%c')"),
735 CGEN_SYNTAX_CHAR(*syn
), *str
);
740 /* Ran out of input. */
741 static char msg
[80];
743 /* xgettext:c-format */
744 sprintf (msg
, _("syntax error (expected char `%c', found end of instruction)"),
745 CGEN_SYNTAX_CHAR(*syn
));
751 #ifdef CGEN_MNEMONIC_OPERANDS
752 (void) past_opcode_p
;
754 /* We have an operand of some sort. */
755 errmsg
= cd
->parse_operand (cd
, CGEN_SYNTAX_FIELD (*syn
), &str
, fields
);
759 /* Done with this operand, continue with next one. */
763 /* If we're at the end of the syntax string, we're done. */
766 /* FIXME: For the moment we assume a valid `str' can only contain
767 blanks now. IE: We needn't try again with a longer version of
768 the insn and it is assumed that longer versions of insns appear
769 before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3). */
770 while (ISSPACE (* str
))
774 return _("junk at end of line"); /* FIXME: would like to include `str' */
779 /* We couldn't parse it. */
780 return _("unrecognized instruction");
784 This routine is called for each instruction to be assembled.
785 STR points to the insn to be assembled.
786 We assume all necessary tables have been initialized.
787 The assembled instruction, less any fixups, is stored in BUF.
788 Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
789 still needs to be converted to target byte order, otherwise BUF is an array
790 of bytes in target byte order.
791 The result is a pointer to the insn's entry in the opcode table,
792 or NULL if an error occured (an error message will have already been
795 Note that when processing (non-alias) macro-insns,
796 this function recurses.
798 ??? It's possible to make this cpu-independent.
799 One would have to deal with a few minor things.
800 At this point in time doing so would be more of a curiosity than useful
801 [for example this file isn't _that_ big], but keeping the possibility in
802 mind helps keep the design clean. */
805 or1k_cgen_assemble_insn (CGEN_CPU_DESC cd
,
808 CGEN_INSN_BYTES_PTR buf
,
812 CGEN_INSN_LIST
*ilist
;
813 const char *parse_errmsg
= NULL
;
814 const char *insert_errmsg
= NULL
;
815 int recognized_mnemonic
= 0;
817 /* Skip leading white space. */
818 while (ISSPACE (* str
))
821 /* The instructions are stored in hashed lists.
822 Get the first in the list. */
823 ilist
= CGEN_ASM_LOOKUP_INSN (cd
, str
);
825 /* Keep looking until we find a match. */
827 for ( ; ilist
!= NULL
; ilist
= CGEN_ASM_NEXT_INSN (ilist
))
829 const CGEN_INSN
*insn
= ilist
->insn
;
830 recognized_mnemonic
= 1;
832 #ifdef CGEN_VALIDATE_INSN_SUPPORTED
833 /* Not usually needed as unsupported opcodes
834 shouldn't be in the hash lists. */
835 /* Is this insn supported by the selected cpu? */
836 if (! or1k_cgen_insn_supported (cd
, insn
))
839 /* If the RELAXED attribute is set, this is an insn that shouldn't be
840 chosen immediately. Instead, it is used during assembler/linker
841 relaxation if possible. */
842 if (CGEN_INSN_ATTR_VALUE (insn
, CGEN_INSN_RELAXED
) != 0)
847 /* Skip this insn if str doesn't look right lexically. */
848 if (CGEN_INSN_RX (insn
) != NULL
&&
849 regexec ((regex_t
*) CGEN_INSN_RX (insn
), str
, 0, NULL
, 0) == REG_NOMATCH
)
852 /* Allow parse/insert handlers to obtain length of insn. */
853 CGEN_FIELDS_BITSIZE (fields
) = CGEN_INSN_BITSIZE (insn
);
855 parse_errmsg
= CGEN_PARSE_FN (cd
, insn
) (cd
, insn
, & str
, fields
);
856 if (parse_errmsg
!= NULL
)
859 /* ??? 0 is passed for `pc'. */
860 insert_errmsg
= CGEN_INSERT_FN (cd
, insn
) (cd
, insn
, fields
, buf
,
862 if (insert_errmsg
!= NULL
)
865 /* It is up to the caller to actually output the insn and any
871 static char errbuf
[150];
872 const char *tmp_errmsg
;
873 #ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
881 /* If requesting verbose error messages, use insert_errmsg.
882 Failing that, use parse_errmsg. */
883 tmp_errmsg
= (insert_errmsg
? insert_errmsg
:
884 parse_errmsg
? parse_errmsg
:
885 recognized_mnemonic
?
886 _("unrecognized form of instruction") :
887 _("unrecognized instruction"));
889 if (strlen (start
) > 50)
890 /* xgettext:c-format */
891 sprintf (errbuf
, "%s `%.50s...'", tmp_errmsg
, start
);
893 /* xgettext:c-format */
894 sprintf (errbuf
, "%s `%.50s'", tmp_errmsg
, start
);
898 if (strlen (start
) > 50)
899 /* xgettext:c-format */
900 sprintf (errbuf
, _("bad instruction `%.50s...'"), start
);
902 /* xgettext:c-format */
903 sprintf (errbuf
, _("bad instruction `%.50s'"), start
);