projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Change source files over to GPLv3.
[deliverable/binutils-gdb.git] / opcodes / xc16x-asm.c
CommitLineData
d70c5fc7
NC		 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
9b201bb5 7 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2005, 2007
d70c5fc7
NC		 8 Free Software Foundation, Inc.
9
9b201bb5 10 This file is part of libopcodes.
d70c5fc7 11
9b201bb5 12 This library is free software; you can redistribute it and/or modify
d70c5fc7 13 it under the terms of the GNU General Public License as published by
9b201bb5 14 the Free Software Foundation; either version 3, or (at your option)
d70c5fc7
NC		 15 any later version.
16
9b201bb5
NC		 17 It is distributed in the hope that it will be useful, but WITHOUT
18 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
19 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
20 License for more details.
d70c5fc7
NC		 21
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. */
25
9b201bb5 26
d70c5fc7
NC		 27/* ??? Eventually more and more of this stuff can go to cpu-independent files.
28 Keep that in mind. */
29
30#include "sysdep.h"
31#include <stdio.h>
32#include "ansidecl.h"
33#include "bfd.h"
34#include "symcat.h"
35#include "xc16x-desc.h"
36#include "xc16x-opc.h"
37#include "opintl.h"
38#include "xregex.h"
39#include "libiberty.h"
40#include "safe-ctype.h"
41
42#undef min
43#define min(a,b) ((a) < (b) ? (a) : (b))
44#undef max
45#define max(a,b) ((a) > (b) ? (a) : (b))
46
47static const char * parse_insn_normal
48 (CGEN_CPU_DESC, const CGEN_INSN *, const char **, CGEN_FIELDS *);
49\f
50/* -- assembler routines inserted here. */
51
52/* -- asm.c */
53/* Handle '#' prefixes (i.e. skip over them). */
54
55static const char *
56parse_hash (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
57 const char **strp,
58 int opindex ATTRIBUTE_UNUSED,
59 long *valuep ATTRIBUTE_UNUSED)
60{
61 if (**strp == '#')
c7d41dc5
NC		 62 {
63 ++*strp;
64 return NULL;
65 }
66 return _("Missing '#' prefix");
d70c5fc7
NC		 67}
68
69/* Handle '.' prefixes (i.e. skip over them). */
70
71static const char *
72parse_dot (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
73 const char **strp,
74 int opindex ATTRIBUTE_UNUSED,
75 long *valuep ATTRIBUTE_UNUSED)
76{
77 if (**strp == '.')
c7d41dc5
NC		 78 {
79 ++*strp;
80 return NULL;
81 }
82 return _("Missing '.' prefix");
d70c5fc7
NC		 83}
84
c7d41dc5 85/* Handle 'pof:' prefixes (i.e. skip over them). */
d70c5fc7
NC		 86
87static const char *
88parse_pof (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
89 const char **strp,
90 int opindex ATTRIBUTE_UNUSED,
91 long *valuep ATTRIBUTE_UNUSED)
92{
c7d41dc5
NC		 93 if (strncasecmp (*strp, "pof:", 4) == 0)
94 {
95 *strp += 4;
96 return NULL;
97 }
98 return _("Missing 'pof:' prefix");
d70c5fc7
NC		 99}
100
c7d41dc5 101/* Handle 'pag:' prefixes (i.e. skip over them). */
d70c5fc7
NC		 102
103static const char *
104parse_pag (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
105 const char **strp,
106 int opindex ATTRIBUTE_UNUSED,
107 long *valuep ATTRIBUTE_UNUSED)
108{
c7d41dc5
NC		 109 if (strncasecmp (*strp, "pag:", 4) == 0)
110 {
111 *strp += 4;
112 return NULL;
113 }
114 return _("Missing 'pag:' prefix");
d70c5fc7
NC		 115}
116
117/* Handle 'sof' prefixes (i.e. skip over them). */
c7d41dc5 118
d70c5fc7
NC		 119static const char *
120parse_sof (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
121 const char **strp,
122 int opindex ATTRIBUTE_UNUSED,
123 long *valuep ATTRIBUTE_UNUSED)
124{
c7d41dc5
NC		 125 if (strncasecmp (*strp, "sof:", 4) == 0)
126 {
127 *strp += 4;
128 return NULL;
129 }
130 return _("Missing 'sof:' prefix");
d70c5fc7
NC		 131}
132
133/* Handle 'seg' prefixes (i.e. skip over them). */
c7d41dc5 134
d70c5fc7
NC		 135static const char *
136parse_seg (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
137 const char **strp,
138 int opindex ATTRIBUTE_UNUSED,
139 long *valuep ATTRIBUTE_UNUSED)
140{
c7d41dc5
NC		 141 if (strncasecmp (*strp, "seg:", 4) == 0)
142 {
143 *strp += 4;
144 return NULL;
145 }
146 return _("Missing 'seg:' prefix");
d70c5fc7
NC		 147}
148/* -- */
149
150const char * xc16x_cgen_parse_operand
151 (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *);
152
153/* Main entry point for operand parsing.
154
155 This function is basically just a big switch statement. Earlier versions
156 used tables to look up the function to use, but
157 - if the table contains both assembler and disassembler functions then
158 the disassembler contains much of the assembler and vice-versa,
159 - there's a lot of inlining possibilities as things grow,
160 - using a switch statement avoids the function call overhead.
161
162 This function could be moved into `parse_insn_normal', but keeping it
163 separate makes clear the interface between `parse_insn_normal' and each of
164 the handlers. */
165
166const char *
167xc16x_cgen_parse_operand (CGEN_CPU_DESC cd,
168 int opindex,
169 const char ** strp,
170 CGEN_FIELDS * fields)
171{
172 const char * errmsg = NULL;
173 /* Used by scalar operands that still need to be parsed. */
174 long junk ATTRIBUTE_UNUSED;
175
176 switch (opindex)
177 {
178 case XC16X_OPERAND_REGNAM :
179 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_psw_names, & fields->f_reg8);
180 break;
181 case XC16X_OPERAND_BIT01 :
182 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_BIT01, (unsigned long *) (& fields->f_op_1bit));
183 break;
184 case XC16X_OPERAND_BIT1 :
185 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_BIT1, (unsigned long *) (& fields->f_op_bit1));
186 break;
187 case XC16X_OPERAND_BIT2 :
188 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_BIT2, (unsigned long *) (& fields->f_op_bit2));
189 break;
190 case XC16X_OPERAND_BIT4 :
191 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_BIT4, (unsigned long *) (& fields->f_op_bit4));
192 break;
193 case XC16X_OPERAND_BIT8 :
194 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_BIT8, (unsigned long *) (& fields->f_op_bit8));
195 break;
196 case XC16X_OPERAND_BITONE :
197 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_BITONE, (unsigned long *) (& fields->f_op_onebit));
198 break;
199 case XC16X_OPERAND_CADDR :
200 {
201 bfd_vma value = 0;
202 errmsg = cgen_parse_address (cd, strp, XC16X_OPERAND_CADDR, 0, NULL, & value);
203 fields->f_offset16 = value;
204 }
205 break;
206 case XC16X_OPERAND_COND :
207 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_conditioncode_names, & fields->f_condcode);
208 break;
209 case XC16X_OPERAND_DATA8 :
210 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_DATA8, (unsigned long *) (& fields->f_data8));
211 break;
212 case XC16X_OPERAND_DATAHI8 :
213 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_DATAHI8, (unsigned long *) (& fields->f_datahi8));
214 break;
215 case XC16X_OPERAND_DOT :
216 errmsg = parse_dot (cd, strp, XC16X_OPERAND_DOT, (long *) (& junk));
217 break;
218 case XC16X_OPERAND_DR :
219 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_gr_names, & fields->f_r1);
220 break;
221 case XC16X_OPERAND_DRB :
222 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_grb_names, & fields->f_r1);
223 break;
224 case XC16X_OPERAND_DRI :
225 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_gr_names, & fields->f_r4);
226 break;
227 case XC16X_OPERAND_EXTCOND :
228 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_extconditioncode_names, & fields->f_extccode);
229 break;
230 case XC16X_OPERAND_GENREG :
231 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_r8_names, & fields->f_regb8);
232 break;
233 case XC16X_OPERAND_HASH :
234 errmsg = parse_hash (cd, strp, XC16X_OPERAND_HASH, (long *) (& junk));
235 break;
236 case XC16X_OPERAND_ICOND :
237 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_conditioncode_names, & fields->f_icondcode);
238 break;
239 case XC16X_OPERAND_LBIT2 :
240 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_LBIT2, (unsigned long *) (& fields->f_op_lbit2));
241 break;
242 case XC16X_OPERAND_LBIT4 :
243 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_LBIT4, (unsigned long *) (& fields->f_op_lbit4));
244 break;
245 case XC16X_OPERAND_MASK8 :
246 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_MASK8, (unsigned long *) (& fields->f_mask8));
247 break;
248 case XC16X_OPERAND_MASKLO8 :
249 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_MASKLO8, (unsigned long *) (& fields->f_datahi8));
250 break;
251 case XC16X_OPERAND_MEMGR8 :
252 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_memgr8_names, & fields->f_memgr8);
253 break;
254 case XC16X_OPERAND_MEMORY :
255 {
256 bfd_vma value = 0;
257 errmsg = cgen_parse_address (cd, strp, XC16X_OPERAND_MEMORY, 0, NULL, & value);
258 fields->f_memory = value;
259 }
260 break;
261 case XC16X_OPERAND_PAG :
262 errmsg = parse_pag (cd, strp, XC16X_OPERAND_PAG, (long *) (& junk));
263 break;
264 case XC16X_OPERAND_PAGENUM :
265 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_PAGENUM, (unsigned long *) (& fields->f_pagenum));
266 break;
267 case XC16X_OPERAND_POF :
268 errmsg = parse_pof (cd, strp, XC16X_OPERAND_POF, (long *) (& junk));
269 break;
270 case XC16X_OPERAND_QBIT :
271 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_QBIT, (unsigned long *) (& fields->f_qbit));
272 break;
273 case XC16X_OPERAND_QHIBIT :
274 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_QHIBIT, (unsigned long *) (& fields->f_qhibit));
275 break;
276 case XC16X_OPERAND_QLOBIT :
277 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_QLOBIT, (unsigned long *) (& fields->f_qlobit));
278 break;
279 case XC16X_OPERAND_REG8 :
280 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_r8_names, & fields->f_reg8);
281 break;
282 case XC16X_OPERAND_REGB8 :
283 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_grb8_names, & fields->f_regb8);
284 break;
285 case XC16X_OPERAND_REGBMEM8 :
286 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_regbmem8_names, & fields->f_regmem8);
287 break;
288 case XC16X_OPERAND_REGHI8 :
289 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_r8_names, & fields->f_reghi8);
290 break;
291 case XC16X_OPERAND_REGMEM8 :
292 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_regmem8_names, & fields->f_regmem8);
293 break;
294 case XC16X_OPERAND_REGOFF8 :
295 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_r8_names, & fields->f_regoff8);
296 break;
297 case XC16X_OPERAND_REL :
298 errmsg = cgen_parse_signed_integer (cd, strp, XC16X_OPERAND_REL, (long *) (& fields->f_rel8));
299 break;
300 case XC16X_OPERAND_RELHI :
301 errmsg = cgen_parse_signed_integer (cd, strp, XC16X_OPERAND_RELHI, (long *) (& fields->f_relhi8));
302 break;
303 case XC16X_OPERAND_SEG :
304 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_SEG, (unsigned long *) (& fields->f_seg8));
305 break;
306 case XC16X_OPERAND_SEGHI8 :
307 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_SEGHI8, (unsigned long *) (& fields->f_segnum8));
308 break;
309 case XC16X_OPERAND_SEGM :
310 errmsg = parse_seg (cd, strp, XC16X_OPERAND_SEGM, (long *) (& junk));
311 break;
312 case XC16X_OPERAND_SOF :
313 errmsg = parse_sof (cd, strp, XC16X_OPERAND_SOF, (long *) (& junk));
314 break;
315 case XC16X_OPERAND_SR :
316 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_gr_names, & fields->f_r2);
317 break;
318 case XC16X_OPERAND_SR2 :
319 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_gr_names, & fields->f_r0);
320 break;
321 case XC16X_OPERAND_SRB :
322 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_grb_names, & fields->f_r2);
323 break;
324 case XC16X_OPERAND_SRC1 :
325 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_gr_names, & fields->f_r1);
326 break;
327 case XC16X_OPERAND_SRC2 :
328 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_gr_names, & fields->f_r2);
329 break;
330 case XC16X_OPERAND_SRDIV :
331 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_regdiv8_names, & fields->f_reg8);
332 break;
333 case XC16X_OPERAND_U4 :
334 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_reg0_name, & fields->f_uimm4);
335 break;
336 case XC16X_OPERAND_UIMM16 :
337 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_UIMM16, (unsigned long *) (& fields->f_uimm16));
338 break;
339 case XC16X_OPERAND_UIMM2 :
340 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_ext_names, & fields->f_uimm2);
341 break;
342 case XC16X_OPERAND_UIMM3 :
343 errmsg = cgen_parse_keyword (cd, strp, & xc16x_cgen_opval_reg0_name1, & fields->f_uimm3);
344 break;
345 case XC16X_OPERAND_UIMM4 :
346 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_UIMM4, (unsigned long *) (& fields->f_uimm4));
347 break;
348 case XC16X_OPERAND_UIMM7 :
349 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_UIMM7, (unsigned long *) (& fields->f_uimm7));
350 break;
351 case XC16X_OPERAND_UIMM8 :
352 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_UIMM8, (unsigned long *) (& fields->f_uimm8));
353 break;
354 case XC16X_OPERAND_UPAG16 :
355 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_UPAG16, (unsigned long *) (& fields->f_uimm16));
356 break;
357 case XC16X_OPERAND_UPOF16 :
358 {
359 bfd_vma value = 0;
360 errmsg = cgen_parse_address (cd, strp, XC16X_OPERAND_UPOF16, 0, NULL, & value);
361 fields->f_memory = value;
362 }
363 break;
364 case XC16X_OPERAND_USEG16 :
365 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_USEG16, (unsigned long *) (& fields->f_offset16));
366 break;
367 case XC16X_OPERAND_USEG8 :
368 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_USEG8, (unsigned long *) (& fields->f_seg8));
369 break;
370 case XC16X_OPERAND_USOF16 :
371 errmsg = cgen_parse_unsigned_integer (cd, strp, XC16X_OPERAND_USOF16, (unsigned long *) (& fields->f_offset16));
372 break;
373
374 default :
375 /* xgettext:c-format */
376 fprintf (stderr, _("Unrecognized field %d while parsing.\n"), opindex);
377 abort ();
378 }
379
380 return errmsg;
381}
382
383cgen_parse_fn * const xc16x_cgen_parse_handlers[] =
384{
385 parse_insn_normal,
386};
387
388void
389xc16x_cgen_init_asm (CGEN_CPU_DESC cd)
390{
391 xc16x_cgen_init_opcode_table (cd);
392 xc16x_cgen_init_ibld_table (cd);
393 cd->parse_handlers = & xc16x_cgen_parse_handlers[0];
394 cd->parse_operand = xc16x_cgen_parse_operand;
1620f33d
AM		 395#ifdef CGEN_ASM_INIT_HOOK
396CGEN_ASM_INIT_HOOK
397#endif
d70c5fc7
NC		 398}
399
400\f
401
402/* Regex construction routine.
403
404 This translates an opcode syntax string into a regex string,
405 by replacing any non-character syntax element (such as an
406 opcode) with the pattern '.*'
407
408 It then compiles the regex and stores it in the opcode, for
409 later use by xc16x_cgen_assemble_insn
410
411 Returns NULL for success, an error message for failure. */
412
413char *
414xc16x_cgen_build_insn_regex (CGEN_INSN *insn)
415{
416 CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn);
417 const char *mnem = CGEN_INSN_MNEMONIC (insn);
418 char rxbuf[CGEN_MAX_RX_ELEMENTS];
419 char *rx = rxbuf;
420 const CGEN_SYNTAX_CHAR_TYPE *syn;
421 int reg_err;
422
423 syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
424
425 /* Mnemonics come first in the syntax string. */
426 if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
427 return _("missing mnemonic in syntax string");
428 ++syn;
429
430 /* Generate a case sensitive regular expression that emulates case
431 insensitive matching in the "C" locale. We cannot generate a case
432 insensitive regular expression because in Turkish locales, 'i' and 'I'
433 are not equal modulo case conversion. */
434
435 /* Copy the literal mnemonic out of the insn. */
436 for (; *mnem; mnem++)
437 {
438 char c = *mnem;
439
440 if (ISALPHA (c))
441 {
442 *rx++ = '[';
443 *rx++ = TOLOWER (c);
444 *rx++ = TOUPPER (c);
445 *rx++ = ']';
446 }
447 else
448 *rx++ = c;
449 }
450
451 /* Copy any remaining literals from the syntax string into the rx. */
452 for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
453 {
454 if (CGEN_SYNTAX_CHAR_P (* syn))
455 {
456 char c = CGEN_SYNTAX_CHAR (* syn);
457
458 switch (c)
459 {
460 /* Escape any regex metacharacters in the syntax. */
461 case '.': case '[': case '\\':
462 case '*': case '^': case '$':
463
464#ifdef CGEN_ESCAPE_EXTENDED_REGEX
465 case '?': case '{': case '}':
466 case '(': case ')': case '*':
467 case '|': case '+': case ']':
468#endif
469 *rx++ = '\\';
470 *rx++ = c;
471 break;
472
473 default:
474 if (ISALPHA (c))
475 {
476 *rx++ = '[';
477 *rx++ = TOLOWER (c);
478 *rx++ = TOUPPER (c);
479 *rx++ = ']';
480 }
481 else
482 *rx++ = c;
483 break;
484 }
485 }
486 else
487 {
488 /* Replace non-syntax fields with globs. */
489 *rx++ = '.';
490 *rx++ = '*';
491 }
492 }
493
494 /* Trailing whitespace ok. */
495 * rx++ = '[';
496 * rx++ = ' ';
497 * rx++ = '\t';
498 * rx++ = ']';
499 * rx++ = '*';
500
501 /* But anchor it after that. */
502 * rx++ = '$';
503 * rx = '\0';
504
505 CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
506 reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);
507
508 if (reg_err == 0)
509 return NULL;
510 else
511 {
512 static char msg[80];
513
514 regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
515 regfree ((regex_t *) CGEN_INSN_RX (insn));
516 free (CGEN_INSN_RX (insn));
517 (CGEN_INSN_RX (insn)) = NULL;
518 return msg;
519 }
520}
521
522\f
523/* Default insn parser.
524
525 The syntax string is scanned and operands are parsed and stored in FIELDS.
526 Relocs are queued as we go via other callbacks.
527
528 ??? Note that this is currently an all-or-nothing parser. If we fail to
529 parse the instruction, we return 0 and the caller will start over from
530 the beginning. Backtracking will be necessary in parsing subexpressions,
531 but that can be handled there. Not handling backtracking here may get
532 expensive in the case of the m68k. Deal with later.
533
534 Returns NULL for success, an error message for failure. */
535
536static const char *
537parse_insn_normal (CGEN_CPU_DESC cd,
538 const CGEN_INSN *insn,
539 const char **strp,
540 CGEN_FIELDS *fields)
541{
542 /* ??? Runtime added insns not handled yet. */
543 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
544 const char *str = *strp;
545 const char *errmsg;
546 const char *p;
547 const CGEN_SYNTAX_CHAR_TYPE * syn;
548#ifdef CGEN_MNEMONIC_OPERANDS
549 /* FIXME: wip */
550 int past_opcode_p;
551#endif
552
553 /* For now we assume the mnemonic is first (there are no leading operands).
554 We can parse it without needing to set up operand parsing.
555 GAS's input scrubber will ensure mnemonics are lowercase, but we may
556 not be called from GAS. */
557 p = CGEN_INSN_MNEMONIC (insn);
558 while (*p && TOLOWER (*p) == TOLOWER (*str))
559 ++p, ++str;
560
561 if (* p)
562 return _("unrecognized instruction");
563
564#ifndef CGEN_MNEMONIC_OPERANDS
565 if (* str && ! ISSPACE (* str))
566 return _("unrecognized instruction");
567#endif
568
569 CGEN_INIT_PARSE (cd);
570 cgen_init_parse_operand (cd);
571#ifdef CGEN_MNEMONIC_OPERANDS
572 past_opcode_p = 0;
573#endif
574
575 /* We don't check for (*str != '\0') here because we want to parse
576 any trailing fake arguments in the syntax string. */
577 syn = CGEN_SYNTAX_STRING (syntax);
578
579 /* Mnemonics come first for now, ensure valid string. */
580 if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
581 abort ();
582
583 ++syn;
584
585 while (* syn != 0)
586 {
587 /* Non operand chars must match exactly. */
588 if (CGEN_SYNTAX_CHAR_P (* syn))
589 {
590 /* FIXME: While we allow for non-GAS callers above, we assume the
591 first char after the mnemonic part is a space. */
592 /* FIXME: We also take inappropriate advantage of the fact that
593 GAS's input scrubber will remove extraneous blanks. */
594 if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
595 {
596#ifdef CGEN_MNEMONIC_OPERANDS
597 if (CGEN_SYNTAX_CHAR(* syn) == ' ')
598 past_opcode_p = 1;
599#endif
600 ++ syn;
601 ++ str;
602 }
603 else if (*str)
604 {
605 /* Syntax char didn't match. Can't be this insn. */
606 static char msg [80];
607
608 /* xgettext:c-format */
609 sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
610 CGEN_SYNTAX_CHAR(*syn), *str);
611 return msg;
612 }
613 else
614 {
615 /* Ran out of input. */
616 static char msg [80];
617
618 /* xgettext:c-format */
619 sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
620 CGEN_SYNTAX_CHAR(*syn));
621 return msg;
622 }
623 continue;
624 }
625
626 /* We have an operand of some sort. */
627 errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn),
628 &str, fields);
629 if (errmsg)
630 return errmsg;
631
632 /* Done with this operand, continue with next one. */
633 ++ syn;
634 }
635
636 /* If we're at the end of the syntax string, we're done. */
637 if (* syn == 0)
638 {
639 /* FIXME: For the moment we assume a valid `str' can only contain
640 blanks now. IE: We needn't try again with a longer version of
641 the insn and it is assumed that longer versions of insns appear
642 before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3). */
643 while (ISSPACE (* str))
644 ++ str;
645
646 if (* str != '\0')
647 return _("junk at end of line"); /* FIXME: would like to include `str' */
648
649 return NULL;
650 }
651
652 /* We couldn't parse it. */
653 return _("unrecognized instruction");
654}
655\f
656/* Main entry point.
657 This routine is called for each instruction to be assembled.
658 STR points to the insn to be assembled.
659 We assume all necessary tables have been initialized.
660 The assembled instruction, less any fixups, is stored in BUF.
661 Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value
662 still needs to be converted to target byte order, otherwise BUF is an array
663 of bytes in target byte order.
664 The result is a pointer to the insn's entry in the opcode table,
665 or NULL if an error occured (an error message will have already been
666 printed).
667
668 Note that when processing (non-alias) macro-insns,
669 this function recurses.
670
671 ??? It's possible to make this cpu-independent.
672 One would have to deal with a few minor things.
673 At this point in time doing so would be more of a curiosity than useful
674 [for example this file isn't _that_ big], but keeping the possibility in
675 mind helps keep the design clean. */
676
677const CGEN_INSN *
678xc16x_cgen_assemble_insn (CGEN_CPU_DESC cd,
679 const char *str,
680 CGEN_FIELDS *fields,
681 CGEN_INSN_BYTES_PTR buf,
682 char **errmsg)
683{
684 const char *start;
685 CGEN_INSN_LIST *ilist;
686 const char *parse_errmsg = NULL;
687 const char *insert_errmsg = NULL;
688 int recognized_mnemonic = 0;
689
690 /* Skip leading white space. */
691 while (ISSPACE (* str))
692 ++ str;
693
694 /* The instructions are stored in hashed lists.
695 Get the first in the list. */
696 ilist = CGEN_ASM_LOOKUP_INSN (cd, str);
697
698 /* Keep looking until we find a match. */
699 start = str;
700 for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
701 {
702 const CGEN_INSN *insn = ilist->insn;
703 recognized_mnemonic = 1;
704
705#ifdef CGEN_VALIDATE_INSN_SUPPORTED
706 /* Not usually needed as unsupported opcodes
707 shouldn't be in the hash lists. */
708 /* Is this insn supported by the selected cpu? */
709 if (! xc16x_cgen_insn_supported (cd, insn))
710 continue;
711#endif
712 /* If the RELAXED attribute is set, this is an insn that shouldn't be
713 chosen immediately. Instead, it is used during assembler/linker
714 relaxation if possible. */
715 if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0)
716 continue;
717
718 str = start;
719
720 /* Skip this insn if str doesn't look right lexically. */
721 if (CGEN_INSN_RX (insn) != NULL &&
722 regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
723 continue;
724
725 /* Allow parse/insert handlers to obtain length of insn. */
726 CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
727
728 parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields);
729 if (parse_errmsg != NULL)
730 continue;
731
732 /* ??? 0 is passed for `pc'. */
733 insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
734 (bfd_vma) 0);
735 if (insert_errmsg != NULL)
736 continue;
737
738 /* It is up to the caller to actually output the insn and any
739 queued relocs. */
740 return insn;
741 }
742
743 {
744 static char errbuf[150];
745#ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
746 const char *tmp_errmsg;
747
748 /* If requesting verbose error messages, use insert_errmsg.
749 Failing that, use parse_errmsg. */
750 tmp_errmsg = (insert_errmsg ? insert_errmsg :
751 parse_errmsg ? parse_errmsg :
752 recognized_mnemonic ?
753 _("unrecognized form of instruction") :
754 _("unrecognized instruction"));
755
756 if (strlen (start) > 50)
757 /* xgettext:c-format */
758 sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start);
759 else
760 /* xgettext:c-format */
761 sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start);
762#else
763 if (strlen (start) > 50)
764 /* xgettext:c-format */
765 sprintf (errbuf, _("bad instruction `%.50s...'"), start);
766 else
767 /* xgettext:c-format */
768 sprintf (errbuf, _("bad instruction `%.50s'"), start);
769#endif
770
771 *errmsg = errbuf;
772 return NULL;
773 }
774}
GDB Binutils - Deliverables
This page took 0.119652 seconds and 4 git commands to generate.