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, 1997, 1998, 1999, 2000, 2001, 2005
8 Free Software Foundation, Inc.
10 This file is part of the GNU Binutils and GDB, the GNU debugger.
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2, or (at your option)
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software Foundation, Inc.,
24 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
26 /* ??? Eventually more and more of this stuff can go to cpu-independent files.
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. */
52 /* Range checking for signed numbers. Returns 0 if acceptable
53 and 1 if the value is out of bounds for a signed quantity. */
56 signed_out_of_bounds (long val
)
58 if ((val
< -32768) || (val
> 32767))
64 parse_loopsize (CGEN_CPU_DESC cd
,
69 signed long * valuep
= (signed long *) arg
;
71 bfd_reloc_code_real_type code
= BFD_RELOC_NONE
;
72 enum cgen_parse_operand_result result_type
;
75 /* Is it a control transfer instructions? */
76 if (opindex
== (CGEN_OPERAND_TYPE
) MT_OPERAND_LOOPSIZE
)
78 code
= BFD_RELOC_MT_PCINSN8
;
79 errmsg
= cgen_parse_address (cd
, strp
, opindex
, code
,
80 & result_type
, & value
);
89 parse_imm16 (CGEN_CPU_DESC cd
,
94 signed long * valuep
= (signed long *) arg
;
96 enum cgen_parse_operand_result result_type
;
97 bfd_reloc_code_real_type code
= BFD_RELOC_NONE
;
100 /* Is it a control transfer instructions? */
101 if (opindex
== (CGEN_OPERAND_TYPE
) MT_OPERAND_IMM16O
)
103 code
= BFD_RELOC_16_PCREL
;
104 errmsg
= cgen_parse_address (cd
, strp
, opindex
, code
,
105 & result_type
, & value
);
108 if (signed_out_of_bounds (value
))
109 errmsg
= _("Operand out of range. Must be between -32768 and 32767.");
115 /* If it's not a control transfer instruction, then
116 we have to check for %OP relocating operators. */
117 if (opindex
== (CGEN_OPERAND_TYPE
) MT_OPERAND_IMM16L
)
119 else if (strncmp (*strp
, "%hi16", 5) == 0)
122 code
= BFD_RELOC_HI16
;
124 else if (strncmp (*strp
, "%lo16", 5) == 0)
127 code
= BFD_RELOC_LO16
;
130 /* If we found a %OP relocating operator, then parse it as an address.
131 If not, we need to parse it as an integer, either signed or unsigned
132 depending on which operand type we have. */
133 if (code
!= BFD_RELOC_NONE
)
135 /* %OP relocating operator found. */
136 errmsg
= cgen_parse_address (cd
, strp
, opindex
, code
,
137 & result_type
, & value
);
142 case (CGEN_PARSE_OPERAND_RESULT_NUMBER
):
143 if (code
== BFD_RELOC_HI16
)
144 value
= (value
>> 16) & 0xFFFF;
145 else if (code
== BFD_RELOC_LO16
)
146 value
= value
& 0xFFFF;
148 errmsg
= _("Biiiig Trouble in parse_imm16!");
151 case (CGEN_PARSE_OPERAND_RESULT_QUEUED
):
152 /* No special processing for this case. */
156 errmsg
= _("%operator operand is not a symbol");
164 /* Parse hex values like 0xffff as unsigned, and sign extend
166 int parse_signed
= (opindex
== (CGEN_OPERAND_TYPE
)MT_OPERAND_IMM16
);
168 if ((*strp
)[0] == '0'
169 && ((*strp
)[1] == 'x' || (*strp
)[1] == 'X'))
172 /* No relocating operator. Parse as an number. */
175 /* Parse as as signed integer. */
177 errmsg
= cgen_parse_signed_integer (cd
, strp
, opindex
, valuep
);
182 /* Manual range checking is needed for the signed case. */
183 if (*valuep
& 0x8000)
184 value
= 0xffff0000 | *valuep
;
188 if (signed_out_of_bounds (value
))
189 errmsg
= _("Operand out of range. Must be between -32768 and 32767.");
190 /* Truncate to 16 bits. This is necessary
191 because cgen will have sign extended *valuep. */
198 /* MT_OPERAND_IMM16Z. Parse as an unsigned integer. */
199 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, opindex
, (unsigned long *) valuep
);
201 if (opindex
== (CGEN_OPERAND_TYPE
) MT_OPERAND_IMM16
203 && *valuep
<= 0xffff)
213 parse_dup (CGEN_CPU_DESC cd
,
216 unsigned long *valuep
)
218 const char *errmsg
= NULL
;
220 if (strncmp (*strp
, "dup", 3) == 0 || strncmp (*strp
, "DUP", 3) == 0)
225 else if (strncmp (*strp
, "xx", 2) == 0 || strncmp (*strp
, "XX", 2) == 0)
231 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, opindex
, valuep
);
238 parse_ball (CGEN_CPU_DESC cd
,
241 unsigned long *valuep
)
243 const char *errmsg
= NULL
;
245 if (strncmp (*strp
, "all", 3) == 0 || strncmp (*strp
, "ALL", 3) == 0)
250 else if (strncmp (*strp
, "one", 3) == 0 || strncmp (*strp
, "ONE", 3) == 0)
256 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, opindex
, valuep
);
262 parse_xmode (CGEN_CPU_DESC cd
,
265 unsigned long *valuep
)
267 const char *errmsg
= NULL
;
269 if (strncmp (*strp
, "pm", 2) == 0 || strncmp (*strp
, "PM", 2) == 0)
274 else if (strncmp (*strp
, "xm", 2) == 0 || strncmp (*strp
, "XM", 2) == 0)
280 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, opindex
, valuep
);
286 parse_rc (CGEN_CPU_DESC cd
,
289 unsigned long *valuep
)
291 const char *errmsg
= NULL
;
293 if (strncmp (*strp
, "r", 1) == 0 || strncmp (*strp
, "R", 1) == 0)
298 else if (strncmp (*strp
, "c", 1) == 0 || strncmp (*strp
, "C", 1) == 0)
304 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, opindex
, valuep
);
310 parse_cbrb (CGEN_CPU_DESC cd
,
313 unsigned long *valuep
)
315 const char *errmsg
= NULL
;
317 if (strncmp (*strp
, "rb", 2) == 0 || strncmp (*strp
, "RB", 2) == 0)
322 else if (strncmp (*strp
, "cb", 2) == 0 || strncmp (*strp
, "CB", 2) == 0)
328 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, opindex
, valuep
);
334 parse_rbbc (CGEN_CPU_DESC cd
,
337 unsigned long *valuep
)
339 const char *errmsg
= NULL
;
341 if (strncmp (*strp
, "rt", 2) == 0 || strncmp (*strp
, "RT", 2) == 0)
346 else if (strncmp (*strp
, "br1", 3) == 0 || strncmp (*strp
, "BR1", 3) == 0)
351 else if (strncmp (*strp
, "br2", 3) == 0 || strncmp (*strp
, "BR2", 3) == 0)
356 else if (strncmp (*strp
, "cs", 2) == 0 || strncmp (*strp
, "CS", 2) == 0)
362 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, opindex
, valuep
);
368 parse_type (CGEN_CPU_DESC cd
,
371 unsigned long *valuep
)
373 const char *errmsg
= NULL
;
375 if (strncmp (*strp
, "odd", 3) == 0 || strncmp (*strp
, "ODD", 3) == 0)
380 else if (strncmp (*strp
, "even", 4) == 0 || strncmp (*strp
, "EVEN", 4) == 0)
385 else if (strncmp (*strp
, "oe", 2) == 0 || strncmp (*strp
, "OE", 2) == 0)
391 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, opindex
, valuep
);
393 if ((errmsg
== NULL
) && (*valuep
== 3))
394 errmsg
= _("invalid operand. type may have values 0,1,2 only.");
401 const char * mt_cgen_parse_operand
402 (CGEN_CPU_DESC
, int, const char **, CGEN_FIELDS
*);
404 /* Main entry point for operand parsing.
406 This function is basically just a big switch statement. Earlier versions
407 used tables to look up the function to use, but
408 - if the table contains both assembler and disassembler functions then
409 the disassembler contains much of the assembler and vice-versa,
410 - there's a lot of inlining possibilities as things grow,
411 - using a switch statement avoids the function call overhead.
413 This function could be moved into `parse_insn_normal', but keeping it
414 separate makes clear the interface between `parse_insn_normal' and each of
418 mt_cgen_parse_operand (CGEN_CPU_DESC cd
,
421 CGEN_FIELDS
* fields
)
423 const char * errmsg
= NULL
;
424 /* Used by scalar operands that still need to be parsed. */
425 long junk ATTRIBUTE_UNUSED
;
429 case MT_OPERAND_A23
:
430 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_A23
, (unsigned long *) (& fields
->f_a23
));
432 case MT_OPERAND_BALL
:
433 errmsg
= parse_ball (cd
, strp
, MT_OPERAND_BALL
, (unsigned long *) (& fields
->f_ball
));
435 case MT_OPERAND_BALL2
:
436 errmsg
= parse_ball (cd
, strp
, MT_OPERAND_BALL2
, (unsigned long *) (& fields
->f_ball2
));
438 case MT_OPERAND_BANKADDR
:
439 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_BANKADDR
, (unsigned long *) (& fields
->f_bankaddr
));
441 case MT_OPERAND_BRC
:
442 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_BRC
, (unsigned long *) (& fields
->f_brc
));
444 case MT_OPERAND_BRC2
:
445 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_BRC2
, (unsigned long *) (& fields
->f_brc2
));
447 case MT_OPERAND_CB1INCR
:
448 errmsg
= cgen_parse_signed_integer (cd
, strp
, MT_OPERAND_CB1INCR
, (long *) (& fields
->f_cb1incr
));
450 case MT_OPERAND_CB1SEL
:
451 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_CB1SEL
, (unsigned long *) (& fields
->f_cb1sel
));
453 case MT_OPERAND_CB2INCR
:
454 errmsg
= cgen_parse_signed_integer (cd
, strp
, MT_OPERAND_CB2INCR
, (long *) (& fields
->f_cb2incr
));
456 case MT_OPERAND_CB2SEL
:
457 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_CB2SEL
, (unsigned long *) (& fields
->f_cb2sel
));
459 case MT_OPERAND_CBRB
:
460 errmsg
= parse_cbrb (cd
, strp
, MT_OPERAND_CBRB
, (unsigned long *) (& fields
->f_cbrb
));
462 case MT_OPERAND_CBS
:
463 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_CBS
, (unsigned long *) (& fields
->f_cbs
));
465 case MT_OPERAND_CBX
:
466 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_CBX
, (unsigned long *) (& fields
->f_cbx
));
468 case MT_OPERAND_CCB
:
469 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_CCB
, (unsigned long *) (& fields
->f_ccb
));
471 case MT_OPERAND_CDB
:
472 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_CDB
, (unsigned long *) (& fields
->f_cdb
));
474 case MT_OPERAND_CELL
:
475 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_CELL
, (unsigned long *) (& fields
->f_cell
));
477 case MT_OPERAND_COLNUM
:
478 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_COLNUM
, (unsigned long *) (& fields
->f_colnum
));
480 case MT_OPERAND_CONTNUM
:
481 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_CONTNUM
, (unsigned long *) (& fields
->f_contnum
));
484 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_CR
, (unsigned long *) (& fields
->f_cr
));
486 case MT_OPERAND_CTXDISP
:
487 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_CTXDISP
, (unsigned long *) (& fields
->f_ctxdisp
));
489 case MT_OPERAND_DUP
:
490 errmsg
= parse_dup (cd
, strp
, MT_OPERAND_DUP
, (unsigned long *) (& fields
->f_dup
));
492 case MT_OPERAND_FBDISP
:
493 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_FBDISP
, (unsigned long *) (& fields
->f_fbdisp
));
495 case MT_OPERAND_FBINCR
:
496 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_FBINCR
, (unsigned long *) (& fields
->f_fbincr
));
498 case MT_OPERAND_FRDR
:
499 errmsg
= cgen_parse_keyword (cd
, strp
, & mt_cgen_opval_h_spr
, & fields
->f_dr
);
501 case MT_OPERAND_FRDRRR
:
502 errmsg
= cgen_parse_keyword (cd
, strp
, & mt_cgen_opval_h_spr
, & fields
->f_drrr
);
504 case MT_OPERAND_FRSR1
:
505 errmsg
= cgen_parse_keyword (cd
, strp
, & mt_cgen_opval_h_spr
, & fields
->f_sr1
);
507 case MT_OPERAND_FRSR2
:
508 errmsg
= cgen_parse_keyword (cd
, strp
, & mt_cgen_opval_h_spr
, & fields
->f_sr2
);
511 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_ID
, (unsigned long *) (& fields
->f_id
));
513 case MT_OPERAND_IMM16
:
514 errmsg
= parse_imm16 (cd
, strp
, MT_OPERAND_IMM16
, (long *) (& fields
->f_imm16s
));
516 case MT_OPERAND_IMM16L
:
517 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_IMM16L
, (unsigned long *) (& fields
->f_imm16l
));
519 case MT_OPERAND_IMM16O
:
520 errmsg
= parse_imm16 (cd
, strp
, MT_OPERAND_IMM16O
, (unsigned long *) (& fields
->f_imm16s
));
522 case MT_OPERAND_IMM16Z
:
523 errmsg
= parse_imm16 (cd
, strp
, MT_OPERAND_IMM16Z
, (unsigned long *) (& fields
->f_imm16u
));
525 case MT_OPERAND_INCAMT
:
526 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_INCAMT
, (unsigned long *) (& fields
->f_incamt
));
528 case MT_OPERAND_INCR
:
529 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_INCR
, (unsigned long *) (& fields
->f_incr
));
531 case MT_OPERAND_LENGTH
:
532 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_LENGTH
, (unsigned long *) (& fields
->f_length
));
534 case MT_OPERAND_LOOPSIZE
:
535 errmsg
= parse_loopsize (cd
, strp
, MT_OPERAND_LOOPSIZE
, (unsigned long *) (& fields
->f_loopo
));
537 case MT_OPERAND_MASK
:
538 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_MASK
, (unsigned long *) (& fields
->f_mask
));
540 case MT_OPERAND_MASK1
:
541 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_MASK1
, (unsigned long *) (& fields
->f_mask1
));
543 case MT_OPERAND_MODE
:
544 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_MODE
, (unsigned long *) (& fields
->f_mode
));
546 case MT_OPERAND_PERM
:
547 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_PERM
, (unsigned long *) (& fields
->f_perm
));
549 case MT_OPERAND_RBBC
:
550 errmsg
= parse_rbbc (cd
, strp
, MT_OPERAND_RBBC
, (unsigned long *) (& fields
->f_rbbc
));
553 errmsg
= parse_rc (cd
, strp
, MT_OPERAND_RC
, (unsigned long *) (& fields
->f_rc
));
555 case MT_OPERAND_RC1
:
556 errmsg
= parse_rc (cd
, strp
, MT_OPERAND_RC1
, (unsigned long *) (& fields
->f_rc1
));
558 case MT_OPERAND_RC2
:
559 errmsg
= parse_rc (cd
, strp
, MT_OPERAND_RC2
, (unsigned long *) (& fields
->f_rc2
));
561 case MT_OPERAND_RC3
:
562 errmsg
= parse_rc (cd
, strp
, MT_OPERAND_RC3
, (unsigned long *) (& fields
->f_rc3
));
564 case MT_OPERAND_RCNUM
:
565 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_RCNUM
, (unsigned long *) (& fields
->f_rcnum
));
567 case MT_OPERAND_RDA
:
568 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_RDA
, (unsigned long *) (& fields
->f_rda
));
570 case MT_OPERAND_ROWNUM
:
571 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_ROWNUM
, (unsigned long *) (& fields
->f_rownum
));
573 case MT_OPERAND_ROWNUM1
:
574 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_ROWNUM1
, (unsigned long *) (& fields
->f_rownum1
));
576 case MT_OPERAND_ROWNUM2
:
577 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_ROWNUM2
, (unsigned long *) (& fields
->f_rownum2
));
579 case MT_OPERAND_SIZE
:
580 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_SIZE
, (unsigned long *) (& fields
->f_size
));
582 case MT_OPERAND_TYPE
:
583 errmsg
= parse_type (cd
, strp
, MT_OPERAND_TYPE
, (unsigned long *) (& fields
->f_type
));
586 errmsg
= cgen_parse_unsigned_integer (cd
, strp
, MT_OPERAND_WR
, (unsigned long *) (& fields
->f_wr
));
588 case MT_OPERAND_XMODE
:
589 errmsg
= parse_xmode (cd
, strp
, MT_OPERAND_XMODE
, (unsigned long *) (& fields
->f_xmode
));
593 /* xgettext:c-format */
594 fprintf (stderr
, _("Unrecognized field %d while parsing.\n"), opindex
);
601 cgen_parse_fn
* const mt_cgen_parse_handlers
[] =
607 mt_cgen_init_asm (CGEN_CPU_DESC cd
)
609 mt_cgen_init_opcode_table (cd
);
610 mt_cgen_init_ibld_table (cd
);
611 cd
->parse_handlers
= & mt_cgen_parse_handlers
[0];
612 cd
->parse_operand
= mt_cgen_parse_operand
;
613 #ifdef CGEN_ASM_INIT_HOOK
620 /* Regex construction routine.
622 This translates an opcode syntax string into a regex string,
623 by replacing any non-character syntax element (such as an
624 opcode) with the pattern '.*'
626 It then compiles the regex and stores it in the opcode, for
627 later use by mt_cgen_assemble_insn
629 Returns NULL for success, an error message for failure. */
632 mt_cgen_build_insn_regex (CGEN_INSN
*insn
)
634 CGEN_OPCODE
*opc
= (CGEN_OPCODE
*) CGEN_INSN_OPCODE (insn
);
635 const char *mnem
= CGEN_INSN_MNEMONIC (insn
);
636 char rxbuf
[CGEN_MAX_RX_ELEMENTS
];
638 const CGEN_SYNTAX_CHAR_TYPE
*syn
;
641 syn
= CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc
));
643 /* Mnemonics come first in the syntax string. */
644 if (! CGEN_SYNTAX_MNEMONIC_P (* syn
))
645 return _("missing mnemonic in syntax string");
648 /* Generate a case sensitive regular expression that emulates case
649 insensitive matching in the "C" locale. We cannot generate a case
650 insensitive regular expression because in Turkish locales, 'i' and 'I'
651 are not equal modulo case conversion. */
653 /* Copy the literal mnemonic out of the insn. */
654 for (; *mnem
; mnem
++)
669 /* Copy any remaining literals from the syntax string into the rx. */
670 for(; * syn
!= 0 && rx
<= rxbuf
+ (CGEN_MAX_RX_ELEMENTS
- 7 - 4); ++syn
)
672 if (CGEN_SYNTAX_CHAR_P (* syn
))
674 char c
= CGEN_SYNTAX_CHAR (* syn
);
678 /* Escape any regex metacharacters in the syntax. */
679 case '.': case '[': case '\\':
680 case '*': case '^': case '$':
682 #ifdef CGEN_ESCAPE_EXTENDED_REGEX
683 case '?': case '{': case '}':
684 case '(': case ')': case '*':
685 case '|': case '+': case ']':
706 /* Replace non-syntax fields with globs. */
712 /* Trailing whitespace ok. */
719 /* But anchor it after that. */
723 CGEN_INSN_RX (insn
) = xmalloc (sizeof (regex_t
));
724 reg_err
= regcomp ((regex_t
*) CGEN_INSN_RX (insn
), rxbuf
, REG_NOSUB
);
732 regerror (reg_err
, (regex_t
*) CGEN_INSN_RX (insn
), msg
, 80);
733 regfree ((regex_t
*) CGEN_INSN_RX (insn
));
734 free (CGEN_INSN_RX (insn
));
735 (CGEN_INSN_RX (insn
)) = NULL
;
741 /* Default insn parser.
743 The syntax string is scanned and operands are parsed and stored in FIELDS.
744 Relocs are queued as we go via other callbacks.
746 ??? Note that this is currently an all-or-nothing parser. If we fail to
747 parse the instruction, we return 0 and the caller will start over from
748 the beginning. Backtracking will be necessary in parsing subexpressions,
749 but that can be handled there. Not handling backtracking here may get
750 expensive in the case of the m68k. Deal with later.
752 Returns NULL for success, an error message for failure. */
755 parse_insn_normal (CGEN_CPU_DESC cd
,
756 const CGEN_INSN
*insn
,
760 /* ??? Runtime added insns not handled yet. */
761 const CGEN_SYNTAX
*syntax
= CGEN_INSN_SYNTAX (insn
);
762 const char *str
= *strp
;
765 const CGEN_SYNTAX_CHAR_TYPE
* syn
;
766 #ifdef CGEN_MNEMONIC_OPERANDS
771 /* For now we assume the mnemonic is first (there are no leading operands).
772 We can parse it without needing to set up operand parsing.
773 GAS's input scrubber will ensure mnemonics are lowercase, but we may
774 not be called from GAS. */
775 p
= CGEN_INSN_MNEMONIC (insn
);
776 while (*p
&& TOLOWER (*p
) == TOLOWER (*str
))
780 return _("unrecognized instruction");
782 #ifndef CGEN_MNEMONIC_OPERANDS
783 if (* str
&& ! ISSPACE (* str
))
784 return _("unrecognized instruction");
787 CGEN_INIT_PARSE (cd
);
788 cgen_init_parse_operand (cd
);
789 #ifdef CGEN_MNEMONIC_OPERANDS
793 /* We don't check for (*str != '\0') here because we want to parse
794 any trailing fake arguments in the syntax string. */
795 syn
= CGEN_SYNTAX_STRING (syntax
);
797 /* Mnemonics come first for now, ensure valid string. */
798 if (! CGEN_SYNTAX_MNEMONIC_P (* syn
))
805 /* Non operand chars must match exactly. */
806 if (CGEN_SYNTAX_CHAR_P (* syn
))
808 /* FIXME: While we allow for non-GAS callers above, we assume the
809 first char after the mnemonic part is a space. */
810 /* FIXME: We also take inappropriate advantage of the fact that
811 GAS's input scrubber will remove extraneous blanks. */
812 if (TOLOWER (*str
) == TOLOWER (CGEN_SYNTAX_CHAR (* syn
)))
814 #ifdef CGEN_MNEMONIC_OPERANDS
815 if (CGEN_SYNTAX_CHAR(* syn
) == ' ')
823 /* Syntax char didn't match. Can't be this insn. */
824 static char msg
[80];
826 /* xgettext:c-format */
827 sprintf (msg
, _("syntax error (expected char `%c', found `%c')"),
828 CGEN_SYNTAX_CHAR(*syn
), *str
);
833 /* Ran out of input. */
834 static char msg
[80];
836 /* xgettext:c-format */
837 sprintf (msg
, _("syntax error (expected char `%c', found end of instruction)"),
838 CGEN_SYNTAX_CHAR(*syn
));
844 /* We have an operand of some sort. */
845 errmsg
= cd
->parse_operand (cd
, CGEN_SYNTAX_FIELD (*syn
),
850 /* Done with this operand, continue with next one. */
854 /* If we're at the end of the syntax string, we're done. */
857 /* FIXME: For the moment we assume a valid `str' can only contain
858 blanks now. IE: We needn't try again with a longer version of
859 the insn and it is assumed that longer versions of insns appear
860 before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3). */
861 while (ISSPACE (* str
))
865 return _("junk at end of line"); /* FIXME: would like to include `str' */
870 /* We couldn't parse it. */
871 return _("unrecognized instruction");
875 This routine is called for each instruction to be assembled.
876 STR points to the insn to be assembled.
877 We assume all necessary tables have been initialized.
878 The assembled instruction, less any fixups, is stored in BUF.
879 Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
880 still needs to be converted to target byte order, otherwise BUF is an array
881 of bytes in target byte order.
882 The result is a pointer to the insn's entry in the opcode table,
883 or NULL if an error occured (an error message will have already been
886 Note that when processing (non-alias) macro-insns,
887 this function recurses.
889 ??? It's possible to make this cpu-independent.
890 One would have to deal with a few minor things.
891 At this point in time doing so would be more of a curiosity than useful
892 [for example this file isn't _that_ big], but keeping the possibility in
893 mind helps keep the design clean. */
896 mt_cgen_assemble_insn (CGEN_CPU_DESC cd
,
899 CGEN_INSN_BYTES_PTR buf
,
903 CGEN_INSN_LIST
*ilist
;
904 const char *parse_errmsg
= NULL
;
905 const char *insert_errmsg
= NULL
;
906 int recognized_mnemonic
= 0;
908 /* Skip leading white space. */
909 while (ISSPACE (* str
))
912 /* The instructions are stored in hashed lists.
913 Get the first in the list. */
914 ilist
= CGEN_ASM_LOOKUP_INSN (cd
, str
);
916 /* Keep looking until we find a match. */
918 for ( ; ilist
!= NULL
; ilist
= CGEN_ASM_NEXT_INSN (ilist
))
920 const CGEN_INSN
*insn
= ilist
->insn
;
921 recognized_mnemonic
= 1;
923 #ifdef CGEN_VALIDATE_INSN_SUPPORTED
924 /* Not usually needed as unsupported opcodes
925 shouldn't be in the hash lists. */
926 /* Is this insn supported by the selected cpu? */
927 if (! mt_cgen_insn_supported (cd
, insn
))
930 /* If the RELAXED attribute is set, this is an insn that shouldn't be
931 chosen immediately. Instead, it is used during assembler/linker
932 relaxation if possible. */
933 if (CGEN_INSN_ATTR_VALUE (insn
, CGEN_INSN_RELAXED
) != 0)
938 /* Skip this insn if str doesn't look right lexically. */
939 if (CGEN_INSN_RX (insn
) != NULL
&&
940 regexec ((regex_t
*) CGEN_INSN_RX (insn
), str
, 0, NULL
, 0) == REG_NOMATCH
)
943 /* Allow parse/insert handlers to obtain length of insn. */
944 CGEN_FIELDS_BITSIZE (fields
) = CGEN_INSN_BITSIZE (insn
);
946 parse_errmsg
= CGEN_PARSE_FN (cd
, insn
) (cd
, insn
, & str
, fields
);
947 if (parse_errmsg
!= NULL
)
950 /* ??? 0 is passed for `pc'. */
951 insert_errmsg
= CGEN_INSERT_FN (cd
, insn
) (cd
, insn
, fields
, buf
,
953 if (insert_errmsg
!= NULL
)
956 /* It is up to the caller to actually output the insn and any
962 static char errbuf
[150];
963 #ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
964 const char *tmp_errmsg
;
966 /* If requesting verbose error messages, use insert_errmsg.
967 Failing that, use parse_errmsg. */
968 tmp_errmsg
= (insert_errmsg
? insert_errmsg
:
969 parse_errmsg
? parse_errmsg
:
970 recognized_mnemonic
?
971 _("unrecognized form of instruction") :
972 _("unrecognized instruction"));
974 if (strlen (start
) > 50)
975 /* xgettext:c-format */
976 sprintf (errbuf
, "%s `%.50s...'", tmp_errmsg
, start
);
978 /* xgettext:c-format */
979 sprintf (errbuf
, "%s `%.50s'", tmp_errmsg
, start
);
981 if (strlen (start
) > 50)
982 /* xgettext:c-format */
983 sprintf (errbuf
, _("bad instruction `%.50s...'"), start
);
985 /* xgettext:c-format */
986 sprintf (errbuf
, _("bad instruction `%.50s'"), start
);