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