1 /* DO NOT EDIT! -*- buffer-read-only: t -*- vi:set ro: */ 2 /* Assembler interface for targets using CGEN. -*- C -*- 3 CGEN: Cpu tools GENerator 4 5 THIS FILE IS MACHINE GENERATED WITH CGEN. 6 - the resultant file is machine generated, cgen-asm.in isn't 7 8 Copyright (C) 1996-2020 Free Software Foundation, Inc. 9 10 This file is part of libopcodes. 11 12 This library 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 3, or (at your option) 15 any later version. 16 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. 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 26 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 "or1k-desc.h" 36 #include "or1k-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 47 static const char * parse_insn_normal 48 (CGEN_CPU_DESC, const CGEN_INSN *, const char **, CGEN_FIELDS *); 49 50 /* -- assembler routines inserted here. */ 51 52 /* -- asm.c */ 53 54 static const char * MISSING_CLOSING_PARENTHESIS = N_("missing `)'"); 55 static const char * INVALID_STORE_RELOC = N_("relocation invalid for store"); 56 static const char * INVALID_RELOC_TYPE = N_("internal relocation type invalid"); 57 58 #define CGEN_VERBOSE_ASSEMBLER_ERRORS 59 60 static const char * 61 parse_disp26 (CGEN_CPU_DESC cd, 62 const char ** strp, 63 int opindex, 64 int opinfo ATTRIBUTE_UNUSED, 65 enum cgen_parse_operand_result * resultp, 66 bfd_vma * valuep) 67 { 68 const char *str = *strp; 69 const char *errmsg = NULL; 70 bfd_reloc_code_real_type reloc = BFD_RELOC_OR1K_REL_26; 71 72 if (strncasecmp (str, "plta(", 5) == 0) 73 { 74 *strp = str + 5; 75 reloc = BFD_RELOC_OR1K_PLTA26; 76 } 77 else if (strncasecmp (str, "plt(", 4) == 0) 78 { 79 *strp = str + 4; 80 reloc = BFD_RELOC_OR1K_PLT26; 81 } 82 83 errmsg = cgen_parse_address (cd, strp, opindex, reloc, resultp, valuep); 84 85 if (reloc != BFD_RELOC_OR1K_REL_26) 86 { 87 if (**strp != ')') 88 errmsg = MISSING_CLOSING_PARENTHESIS; 89 else 90 ++*strp; 91 } 92 93 return errmsg; 94 } 95 96 static const char * 97 parse_disp21 (CGEN_CPU_DESC cd, 98 const char ** strp, 99 int opindex, 100 int opinfo ATTRIBUTE_UNUSED, 101 enum cgen_parse_operand_result * resultp, 102 bfd_vma * valuep) 103 { 104 const char *str = *strp; 105 const char *errmsg = NULL; 106 bfd_reloc_code_real_type reloc = BFD_RELOC_OR1K_PCREL_PG21; 107 108 if (strncasecmp (str, "got(", 4) == 0) 109 { 110 *strp = str + 4; 111 reloc = BFD_RELOC_OR1K_GOT_PG21; 112 } 113 else if (strncasecmp (str, "tlsgd(", 6) == 0) 114 { 115 *strp = str + 6; 116 reloc = BFD_RELOC_OR1K_TLS_GD_PG21; 117 } 118 else if (strncasecmp (str, "tlsldm(", 7) == 0) 119 { 120 *strp = str + 7; 121 reloc = BFD_RELOC_OR1K_TLS_LDM_PG21; 122 } 123 else if (strncasecmp (str, "gottp(", 6) == 0) 124 { 125 *strp = str + 6; 126 reloc = BFD_RELOC_OR1K_TLS_IE_PG21; 127 } 128 129 errmsg = cgen_parse_address (cd, strp, opindex, reloc, resultp, valuep); 130 131 if (reloc != BFD_RELOC_OR1K_PCREL_PG21) 132 { 133 if (**strp != ')') 134 errmsg = MISSING_CLOSING_PARENTHESIS; 135 else 136 ++*strp; 137 } 138 139 return errmsg; 140 } 141 142 enum or1k_rclass 143 { 144 RCLASS_DIRECT = 0, 145 RCLASS_GOT = 1, 146 RCLASS_GOTPC = 2, 147 RCLASS_GOTOFF = 3, 148 RCLASS_TLSGD = 4, 149 RCLASS_TLSLDM = 5, 150 RCLASS_DTPOFF = 6, 151 RCLASS_GOTTPOFF = 7, 152 RCLASS_TPOFF = 8, 153 }; 154 155 enum or1k_rtype 156 { 157 RTYPE_LO = 0, 158 RTYPE_SLO = 1, 159 RTYPE_PO = 2, 160 RTYPE_SPO = 3, 161 RTYPE_HI = 4, 162 RTYPE_AHI = 5, 163 }; 164 165 #define RCLASS_SHIFT 3 166 #define RTYPE_MASK 7 167 168 static const bfd_reloc_code_real_type or1k_imm16_relocs[][6] = { 169 { BFD_RELOC_LO16, 170 BFD_RELOC_OR1K_SLO16, 171 BFD_RELOC_OR1K_LO13, 172 BFD_RELOC_OR1K_SLO13, 173 BFD_RELOC_HI16, 174 BFD_RELOC_HI16_S, }, 175 { BFD_RELOC_OR1K_GOT16, 176 BFD_RELOC_UNUSED, 177 BFD_RELOC_OR1K_GOT_LO13, 178 BFD_RELOC_UNUSED, 179 BFD_RELOC_UNUSED, 180 BFD_RELOC_UNUSED }, 181 { BFD_RELOC_OR1K_GOTPC_LO16, 182 BFD_RELOC_UNUSED, 183 BFD_RELOC_UNUSED, 184 BFD_RELOC_UNUSED, 185 BFD_RELOC_OR1K_GOTPC_HI16, 186 BFD_RELOC_UNUSED }, 187 { BFD_RELOC_LO16_GOTOFF, 188 BFD_RELOC_OR1K_GOTOFF_SLO16, 189 BFD_RELOC_UNUSED, 190 BFD_RELOC_UNUSED, 191 BFD_RELOC_HI16_GOTOFF, 192 BFD_RELOC_HI16_S_GOTOFF }, 193 { BFD_RELOC_OR1K_TLS_GD_LO16, 194 BFD_RELOC_UNUSED, 195 BFD_RELOC_OR1K_TLS_GD_LO13, 196 BFD_RELOC_UNUSED, 197 BFD_RELOC_OR1K_TLS_GD_HI16, 198 BFD_RELOC_UNUSED }, 199 { BFD_RELOC_OR1K_TLS_LDM_LO16, 200 BFD_RELOC_UNUSED, 201 BFD_RELOC_OR1K_TLS_LDM_LO13, 202 BFD_RELOC_UNUSED, 203 BFD_RELOC_OR1K_TLS_LDM_HI16, 204 BFD_RELOC_UNUSED }, 205 { BFD_RELOC_OR1K_TLS_LDO_LO16, 206 BFD_RELOC_UNUSED, 207 BFD_RELOC_UNUSED, 208 BFD_RELOC_UNUSED, 209 BFD_RELOC_OR1K_TLS_LDO_HI16, 210 BFD_RELOC_UNUSED }, 211 { BFD_RELOC_OR1K_TLS_IE_LO16, 212 BFD_RELOC_UNUSED, 213 BFD_RELOC_OR1K_TLS_IE_LO13, 214 BFD_RELOC_UNUSED, 215 BFD_RELOC_OR1K_TLS_IE_HI16, 216 BFD_RELOC_OR1K_TLS_IE_AHI16 }, 217 { BFD_RELOC_OR1K_TLS_LE_LO16, 218 BFD_RELOC_OR1K_TLS_LE_SLO16, 219 BFD_RELOC_UNUSED, 220 BFD_RELOC_UNUSED, 221 BFD_RELOC_OR1K_TLS_LE_HI16, 222 BFD_RELOC_OR1K_TLS_LE_AHI16 }, 223 }; 224 225 static int 226 parse_reloc (const char **strp) 227 { 228 const char *str = *strp; 229 enum or1k_rclass cls = RCLASS_DIRECT; 230 enum or1k_rtype typ; 231 232 if (strncasecmp (str, "got(", 4) == 0) 233 { 234 *strp = str + 4; 235 return (RCLASS_GOT << RCLASS_SHIFT) | RTYPE_LO; 236 } 237 if (strncasecmp (str, "gotpo(", 6) == 0) 238 { 239 *strp = str + 6; 240 return (RCLASS_GOT << RCLASS_SHIFT) | RTYPE_PO; 241 } 242 if (strncasecmp (str, "gottppo(", 8) == 0) 243 { 244 *strp = str + 8; 245 return (RCLASS_GOTTPOFF << RCLASS_SHIFT) | RTYPE_PO; 246 } 247 248 if (strncasecmp (str, "gotpc", 5) == 0) 249 { 250 str += 5; 251 cls = RCLASS_GOTPC; 252 } 253 else if (strncasecmp (str, "gotoff", 6) == 0) 254 { 255 str += 6; 256 cls = RCLASS_GOTOFF; 257 } 258 else if (strncasecmp (str, "tlsgd", 5) == 0) 259 { 260 str += 5; 261 cls = RCLASS_TLSGD; 262 } 263 else if (strncasecmp (str, "tlsldm", 6) == 0) 264 { 265 str += 6; 266 cls = RCLASS_TLSLDM; 267 } 268 else if (strncasecmp (str, "dtpoff", 6) == 0) 269 { 270 str += 6; 271 cls = RCLASS_DTPOFF; 272 } 273 else if (strncasecmp (str, "gottpoff", 8) == 0) 274 { 275 str += 8; 276 cls = RCLASS_GOTTPOFF; 277 } 278 else if (strncasecmp (str, "tpoff", 5) == 0) 279 { 280 str += 5; 281 cls = RCLASS_TPOFF; 282 } 283 284 if (strncasecmp (str, "hi(", 3) == 0) 285 { 286 str += 3; 287 typ = RTYPE_HI; 288 } 289 else if (strncasecmp (str, "lo(", 3) == 0) 290 { 291 str += 3; 292 typ = RTYPE_LO; 293 } 294 else if (strncasecmp (str, "ha(", 3) == 0) 295 { 296 str += 3; 297 typ = RTYPE_AHI; 298 } 299 else if (strncasecmp (str, "po(", 3) == 0 && cls != RCLASS_GOTTPOFF) 300 { 301 str += 3; 302 typ = RTYPE_PO; 303 } 304 else 305 return -1; 306 307 *strp = str; 308 return (cls << RCLASS_SHIFT) | typ; 309 } 310 311 static const char * 312 parse_imm16 (CGEN_CPU_DESC cd, const char **strp, int opindex, 313 long *valuep, int splitp) 314 { 315 const char *errmsg; 316 enum cgen_parse_operand_result result_type; 317 bfd_reloc_code_real_type reloc = BFD_RELOC_UNUSED; 318 enum or1k_rtype reloc_type; 319 int reloc_code; 320 bfd_vma ret; 321 322 if (**strp == '#') 323 ++*strp; 324 325 reloc_code = parse_reloc (strp); 326 reloc_type = reloc_code & RTYPE_MASK; 327 if (reloc_code >= 0) 328 { 329 enum or1k_rclass reloc_class = reloc_code >> RCLASS_SHIFT; 330 if (splitp) 331 { 332 if ((reloc_type == RTYPE_LO || reloc_type == RTYPE_PO) 333 && reloc_class != RCLASS_GOT) 334 /* If split we or up the type to RTYPE_SLO or RTYPE_SPO. */ 335 reloc_type |= 1; 336 else 337 return INVALID_STORE_RELOC; 338 } 339 reloc = or1k_imm16_relocs[reloc_class][reloc_type]; 340 } 341 342 if (reloc != BFD_RELOC_UNUSED) 343 { 344 bfd_vma value; 345 346 errmsg = cgen_parse_address (cd, strp, opindex, reloc, 347 &result_type, &value); 348 if (**strp != ')') 349 errmsg = MISSING_CLOSING_PARENTHESIS; 350 ++*strp; 351 352 ret = value; 353 354 if (errmsg == NULL && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER) 355 switch (reloc_type) 356 { 357 case RTYPE_AHI: 358 ret += 0x8000; 359 /* FALLTHRU */ 360 case RTYPE_HI: 361 ret >>= 16; 362 /* FALLTHRU */ 363 case RTYPE_LO: 364 case RTYPE_SLO: 365 ret &= 0xffff; 366 ret = (ret ^ 0x8000) - 0x8000; 367 break; 368 case RTYPE_PO: 369 case RTYPE_SPO: 370 ret &= 0x1fff; 371 break; 372 default: 373 errmsg = INVALID_RELOC_TYPE; 374 } 375 } 376 else 377 { 378 long value; 379 errmsg = cgen_parse_signed_integer (cd, strp, opindex, &value); 380 ret = value; 381 } 382 383 if (errmsg == NULL) 384 *valuep = ret; 385 386 return errmsg; 387 } 388 389 static const char * 390 parse_simm16 (CGEN_CPU_DESC cd, const char **strp, int opindex, long *valuep) 391 { 392 return parse_imm16(cd, strp, opindex, (long *) valuep, 0); 393 } 394 395 static const char * 396 parse_simm16_split (CGEN_CPU_DESC cd, const char **strp, int opindex, 397 long *valuep) 398 { 399 return parse_imm16(cd, strp, opindex, (long *) valuep, 1); 400 } 401 402 static const char * 403 parse_uimm16 (CGEN_CPU_DESC cd, const char **strp, int opindex, 404 unsigned long *valuep) 405 { 406 const char *errmsg = parse_imm16(cd, strp, opindex, (long *) valuep, 0); 407 if (errmsg == NULL) 408 *valuep &= 0xffff; 409 return errmsg; 410 } 411 412 static const char * 413 parse_uimm16_split (CGEN_CPU_DESC cd, const char **strp, int opindex, 414 unsigned long *valuep) 415 { 416 const char *errmsg = parse_imm16(cd, strp, opindex, (long *) valuep, 1); 417 if (errmsg == NULL) 418 *valuep &= 0xffff; 419 return errmsg; 420 } 421 422 /* Parse register pairs with syntax rA,rB to a flag + rA value. */ 423 424 static const char * 425 parse_regpair (CGEN_CPU_DESC cd, const char **strp, 426 int opindex ATTRIBUTE_UNUSED, unsigned long *valuep) 427 { 428 long reg1_index; 429 long reg2_index; 430 const char *errmsg; 431 432 /* The first part should just be a register. */ 433 errmsg = cgen_parse_keyword (cd, strp, &or1k_cgen_opval_h_gpr, 434 ®1_index); 435 436 /* If that worked skip the comma separator. */ 437 if (errmsg == NULL) 438 { 439 if (**strp == ',') 440 ++*strp; 441 else 442 errmsg = "Unexpected character, expected ','"; 443 } 444 445 /* If that worked the next part is just another register. */ 446 if (errmsg == NULL) 447 errmsg = cgen_parse_keyword (cd, strp, &or1k_cgen_opval_h_gpr, 448 ®2_index); 449 450 /* Validate the register pair is valid and create the output value. */ 451 if (errmsg == NULL) 452 { 453 int regoffset = reg2_index - reg1_index; 454 455 if (regoffset == 1 || regoffset == 2) 456 { 457 unsigned short offsetmask; 458 unsigned short value; 459 460 offsetmask = ((regoffset == 2 ? 1 : 0) << 5); 461 value = offsetmask | reg1_index; 462 463 *valuep = value; 464 } 465 else 466 errmsg = "Invalid register pair, offset not 1 or 2."; 467 } 468 469 return errmsg; 470 } 471 472 /* -- */ 473 474 const char * or1k_cgen_parse_operand 475 (CGEN_CPU_DESC, int, const char **, CGEN_FIELDS *); 476 477 /* Main entry point for operand parsing. 478 479 This function is basically just a big switch statement. Earlier versions 480 used tables to look up the function to use, but 481 - if the table contains both assembler and disassembler functions then 482 the disassembler contains much of the assembler and vice-versa, 483 - there's a lot of inlining possibilities as things grow, 484 - using a switch statement avoids the function call overhead. 485 486 This function could be moved into `parse_insn_normal', but keeping it 487 separate makes clear the interface between `parse_insn_normal' and each of 488 the handlers. */ 489 490 const char * 491 or1k_cgen_parse_operand (CGEN_CPU_DESC cd, 492 int opindex, 493 const char ** strp, 494 CGEN_FIELDS * fields) 495 { 496 const char * errmsg = NULL; 497 /* Used by scalar operands that still need to be parsed. */ 498 long junk ATTRIBUTE_UNUSED; 499 500 switch (opindex) 501 { 502 case OR1K_OPERAND_DISP21 : 503 { 504 bfd_vma value = 0; 505 errmsg = parse_disp21 (cd, strp, OR1K_OPERAND_DISP21, 0, NULL, & value); 506 fields->f_disp21 = value; 507 } 508 break; 509 case OR1K_OPERAND_DISP26 : 510 { 511 bfd_vma value = 0; 512 errmsg = parse_disp26 (cd, strp, OR1K_OPERAND_DISP26, 0, NULL, & value); 513 fields->f_disp26 = value; 514 } 515 break; 516 case OR1K_OPERAND_RA : 517 errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_gpr, & fields->f_r2); 518 break; 519 case OR1K_OPERAND_RAD32F : 520 errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RAD32F, (unsigned long *) (& fields->f_rad32)); 521 break; 522 case OR1K_OPERAND_RADI : 523 errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RADI, (unsigned long *) (& fields->f_rad32)); 524 break; 525 case OR1K_OPERAND_RASF : 526 errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_fsr, & fields->f_r2); 527 break; 528 case OR1K_OPERAND_RB : 529 errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_gpr, & fields->f_r3); 530 break; 531 case OR1K_OPERAND_RBD32F : 532 errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RBD32F, (unsigned long *) (& fields->f_rbd32)); 533 break; 534 case OR1K_OPERAND_RBDI : 535 errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RBDI, (unsigned long *) (& fields->f_rbd32)); 536 break; 537 case OR1K_OPERAND_RBSF : 538 errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_fsr, & fields->f_r3); 539 break; 540 case OR1K_OPERAND_RD : 541 errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_gpr, & fields->f_r1); 542 break; 543 case OR1K_OPERAND_RDD32F : 544 errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RDD32F, (unsigned long *) (& fields->f_rdd32)); 545 break; 546 case OR1K_OPERAND_RDDI : 547 errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RDDI, (unsigned long *) (& fields->f_rdd32)); 548 break; 549 case OR1K_OPERAND_RDSF : 550 errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_fsr, & fields->f_r1); 551 break; 552 case OR1K_OPERAND_SIMM16 : 553 errmsg = parse_simm16 (cd, strp, OR1K_OPERAND_SIMM16, (long *) (& fields->f_simm16)); 554 break; 555 case OR1K_OPERAND_SIMM16_SPLIT : 556 errmsg = parse_simm16_split (cd, strp, OR1K_OPERAND_SIMM16_SPLIT, (long *) (& fields->f_simm16_split)); 557 break; 558 case OR1K_OPERAND_UIMM16 : 559 errmsg = parse_uimm16 (cd, strp, OR1K_OPERAND_UIMM16, (unsigned long *) (& fields->f_uimm16)); 560 break; 561 case OR1K_OPERAND_UIMM16_SPLIT : 562 errmsg = parse_uimm16_split (cd, strp, OR1K_OPERAND_UIMM16_SPLIT, (unsigned long *) (& fields->f_uimm16_split)); 563 break; 564 case OR1K_OPERAND_UIMM6 : 565 errmsg = cgen_parse_unsigned_integer (cd, strp, OR1K_OPERAND_UIMM6, (unsigned long *) (& fields->f_uimm6)); 566 break; 567 568 default : 569 /* xgettext:c-format */ 570 opcodes_error_handler 571 (_("internal error: unrecognized field %d while parsing"), 572 opindex); 573 abort (); 574 } 575 576 return errmsg; 577 } 578 579 cgen_parse_fn * const or1k_cgen_parse_handlers[] = 580 { 581 parse_insn_normal, 582 }; 583 584 void 585 or1k_cgen_init_asm (CGEN_CPU_DESC cd) 586 { 587 or1k_cgen_init_opcode_table (cd); 588 or1k_cgen_init_ibld_table (cd); 589 cd->parse_handlers = & or1k_cgen_parse_handlers[0]; 590 cd->parse_operand = or1k_cgen_parse_operand; 591 #ifdef CGEN_ASM_INIT_HOOK 592 CGEN_ASM_INIT_HOOK 593 #endif 594 } 595 596 597 598 /* Regex construction routine. 599 600 This translates an opcode syntax string into a regex string, 601 by replacing any non-character syntax element (such as an 602 opcode) with the pattern '.*' 603 604 It then compiles the regex and stores it in the opcode, for 605 later use by or1k_cgen_assemble_insn 606 607 Returns NULL for success, an error message for failure. */ 608 609 char * 610 or1k_cgen_build_insn_regex (CGEN_INSN *insn) 611 { 612 CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn); 613 const char *mnem = CGEN_INSN_MNEMONIC (insn); 614 char rxbuf[CGEN_MAX_RX_ELEMENTS]; 615 char *rx = rxbuf; 616 const CGEN_SYNTAX_CHAR_TYPE *syn; 617 int reg_err; 618 619 syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc)); 620 621 /* Mnemonics come first in the syntax string. */ 622 if (! CGEN_SYNTAX_MNEMONIC_P (* syn)) 623 return _("missing mnemonic in syntax string"); 624 ++syn; 625 626 /* Generate a case sensitive regular expression that emulates case 627 insensitive matching in the "C" locale. We cannot generate a case 628 insensitive regular expression because in Turkish locales, 'i' and 'I' 629 are not equal modulo case conversion. */ 630 631 /* Copy the literal mnemonic out of the insn. */ 632 for (; *mnem; mnem++) 633 { 634 char c = *mnem; 635 636 if (ISALPHA (c)) 637 { 638 *rx++ = '['; 639 *rx++ = TOLOWER (c); 640 *rx++ = TOUPPER (c); 641 *rx++ = ']'; 642 } 643 else 644 *rx++ = c; 645 } 646 647 /* Copy any remaining literals from the syntax string into the rx. */ 648 for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn) 649 { 650 if (CGEN_SYNTAX_CHAR_P (* syn)) 651 { 652 char c = CGEN_SYNTAX_CHAR (* syn); 653 654 switch (c) 655 { 656 /* Escape any regex metacharacters in the syntax. */ 657 case '.': case '[': case '\\': 658 case '*': case '^': case '$': 659 660 #ifdef CGEN_ESCAPE_EXTENDED_REGEX 661 case '?': case '{': case '}': 662 case '(': case ')': case '*': 663 case '|': case '+': case ']': 664 #endif 665 *rx++ = '\\'; 666 *rx++ = c; 667 break; 668 669 default: 670 if (ISALPHA (c)) 671 { 672 *rx++ = '['; 673 *rx++ = TOLOWER (c); 674 *rx++ = TOUPPER (c); 675 *rx++ = ']'; 676 } 677 else 678 *rx++ = c; 679 break; 680 } 681 } 682 else 683 { 684 /* Replace non-syntax fields with globs. */ 685 *rx++ = '.'; 686 *rx++ = '*'; 687 } 688 } 689 690 /* Trailing whitespace ok. */ 691 * rx++ = '['; 692 * rx++ = ' '; 693 * rx++ = '\t'; 694 * rx++ = ']'; 695 * rx++ = '*'; 696 697 /* But anchor it after that. */ 698 * rx++ = '$'; 699 * rx = '\0'; 700 701 CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t)); 702 reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB); 703 704 if (reg_err == 0) 705 return NULL; 706 else 707 { 708 static char msg[80]; 709 710 regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80); 711 regfree ((regex_t *) CGEN_INSN_RX (insn)); 712 free (CGEN_INSN_RX (insn)); 713 (CGEN_INSN_RX (insn)) = NULL; 714 return msg; 715 } 716 } 717 718 719 /* Default insn parser. 720 721 The syntax string is scanned and operands are parsed and stored in FIELDS. 722 Relocs are queued as we go via other callbacks. 723 724 ??? Note that this is currently an all-or-nothing parser. If we fail to 725 parse the instruction, we return 0 and the caller will start over from 726 the beginning. Backtracking will be necessary in parsing subexpressions, 727 but that can be handled there. Not handling backtracking here may get 728 expensive in the case of the m68k. Deal with later. 729 730 Returns NULL for success, an error message for failure. */ 731 732 static const char * 733 parse_insn_normal (CGEN_CPU_DESC cd, 734 const CGEN_INSN *insn, 735 const char **strp, 736 CGEN_FIELDS *fields) 737 { 738 /* ??? Runtime added insns not handled yet. */ 739 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn); 740 const char *str = *strp; 741 const char *errmsg; 742 const char *p; 743 const CGEN_SYNTAX_CHAR_TYPE * syn; 744 #ifdef CGEN_MNEMONIC_OPERANDS 745 /* FIXME: wip */ 746 int past_opcode_p; 747 #endif 748 749 /* For now we assume the mnemonic is first (there are no leading operands). 750 We can parse it without needing to set up operand parsing. 751 GAS's input scrubber will ensure mnemonics are lowercase, but we may 752 not be called from GAS. */ 753 p = CGEN_INSN_MNEMONIC (insn); 754 while (*p && TOLOWER (*p) == TOLOWER (*str)) 755 ++p, ++str; 756 757 if (* p) 758 return _("unrecognized instruction"); 759 760 #ifndef CGEN_MNEMONIC_OPERANDS 761 if (* str && ! ISSPACE (* str)) 762 return _("unrecognized instruction"); 763 #endif 764 765 CGEN_INIT_PARSE (cd); 766 cgen_init_parse_operand (cd); 767 #ifdef CGEN_MNEMONIC_OPERANDS 768 past_opcode_p = 0; 769 #endif 770 771 /* We don't check for (*str != '\0') here because we want to parse 772 any trailing fake arguments in the syntax string. */ 773 syn = CGEN_SYNTAX_STRING (syntax); 774 775 /* Mnemonics come first for now, ensure valid string. */ 776 if (! CGEN_SYNTAX_MNEMONIC_P (* syn)) 777 abort (); 778 779 ++syn; 780 781 while (* syn != 0) 782 { 783 /* Non operand chars must match exactly. */ 784 if (CGEN_SYNTAX_CHAR_P (* syn)) 785 { 786 /* FIXME: While we allow for non-GAS callers above, we assume the 787 first char after the mnemonic part is a space. */ 788 /* FIXME: We also take inappropriate advantage of the fact that 789 GAS's input scrubber will remove extraneous blanks. */ 790 if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn))) 791 { 792 #ifdef CGEN_MNEMONIC_OPERANDS 793 if (CGEN_SYNTAX_CHAR(* syn) == ' ') 794 past_opcode_p = 1; 795 #endif 796 ++ syn; 797 ++ str; 798 } 799 else if (*str) 800 { 801 /* Syntax char didn't match. Can't be this insn. */ 802 static char msg [80]; 803 804 /* xgettext:c-format */ 805 sprintf (msg, _("syntax error (expected char `%c', found `%c')"), 806 CGEN_SYNTAX_CHAR(*syn), *str); 807 return msg; 808 } 809 else 810 { 811 /* Ran out of input. */ 812 static char msg [80]; 813 814 /* xgettext:c-format */ 815 sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"), 816 CGEN_SYNTAX_CHAR(*syn)); 817 return msg; 818 } 819 continue; 820 } 821 822 #ifdef CGEN_MNEMONIC_OPERANDS 823 (void) past_opcode_p; 824 #endif 825 /* We have an operand of some sort. */ 826 errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields); 827 if (errmsg) 828 return errmsg; 829 830 /* Done with this operand, continue with next one. */ 831 ++ syn; 832 } 833 834 /* If we're at the end of the syntax string, we're done. */ 835 if (* syn == 0) 836 { 837 /* FIXME: For the moment we assume a valid `str' can only contain 838 blanks now. IE: We needn't try again with a longer version of 839 the insn and it is assumed that longer versions of insns appear 840 before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3). */ 841 while (ISSPACE (* str)) 842 ++ str; 843 844 if (* str != '\0') 845 return _("junk at end of line"); /* FIXME: would like to include `str' */ 846 847 return NULL; 848 } 849 850 /* We couldn't parse it. */ 851 return _("unrecognized instruction"); 852 } 853 854 /* Main entry point. 855 This routine is called for each instruction to be assembled. 856 STR points to the insn to be assembled. 857 We assume all necessary tables have been initialized. 858 The assembled instruction, less any fixups, is stored in BUF. 859 Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value 860 still needs to be converted to target byte order, otherwise BUF is an array 861 of bytes in target byte order. 862 The result is a pointer to the insn's entry in the opcode table, 863 or NULL if an error occured (an error message will have already been 864 printed). 865 866 Note that when processing (non-alias) macro-insns, 867 this function recurses. 868 869 ??? It's possible to make this cpu-independent. 870 One would have to deal with a few minor things. 871 At this point in time doing so would be more of a curiosity than useful 872 [for example this file isn't _that_ big], but keeping the possibility in 873 mind helps keep the design clean. */ 874 875 const CGEN_INSN * 876 or1k_cgen_assemble_insn (CGEN_CPU_DESC cd, 877 const char *str, 878 CGEN_FIELDS *fields, 879 CGEN_INSN_BYTES_PTR buf, 880 char **errmsg) 881 { 882 const char *start; 883 CGEN_INSN_LIST *ilist; 884 const char *parse_errmsg = NULL; 885 const char *insert_errmsg = NULL; 886 int recognized_mnemonic = 0; 887 888 /* Skip leading white space. */ 889 while (ISSPACE (* str)) 890 ++ str; 891 892 /* The instructions are stored in hashed lists. 893 Get the first in the list. */ 894 ilist = CGEN_ASM_LOOKUP_INSN (cd, str); 895 896 /* Keep looking until we find a match. */ 897 start = str; 898 for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist)) 899 { 900 const CGEN_INSN *insn = ilist->insn; 901 recognized_mnemonic = 1; 902 903 #ifdef CGEN_VALIDATE_INSN_SUPPORTED 904 /* Not usually needed as unsupported opcodes 905 shouldn't be in the hash lists. */ 906 /* Is this insn supported by the selected cpu? */ 907 if (! or1k_cgen_insn_supported (cd, insn)) 908 continue; 909 #endif 910 /* If the RELAXED attribute is set, this is an insn that shouldn't be 911 chosen immediately. Instead, it is used during assembler/linker 912 relaxation if possible. */ 913 if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0) 914 continue; 915 916 str = start; 917 918 /* Skip this insn if str doesn't look right lexically. */ 919 if (CGEN_INSN_RX (insn) != NULL && 920 regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH) 921 continue; 922 923 /* Allow parse/insert handlers to obtain length of insn. */ 924 CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn); 925 926 parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields); 927 if (parse_errmsg != NULL) 928 continue; 929 930 /* ??? 0 is passed for `pc'. */ 931 insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf, 932 (bfd_vma) 0); 933 if (insert_errmsg != NULL) 934 continue; 935 936 /* It is up to the caller to actually output the insn and any 937 queued relocs. */ 938 return insn; 939 } 940 941 { 942 static char errbuf[150]; 943 const char *tmp_errmsg; 944 #ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS 945 #define be_verbose 1 946 #else 947 #define be_verbose 0 948 #endif 949 950 if (be_verbose) 951 { 952 /* If requesting verbose error messages, use insert_errmsg. 953 Failing that, use parse_errmsg. */ 954 tmp_errmsg = (insert_errmsg ? insert_errmsg : 955 parse_errmsg ? parse_errmsg : 956 recognized_mnemonic ? 957 _("unrecognized form of instruction") : 958 _("unrecognized instruction")); 959 960 if (strlen (start) > 50) 961 /* xgettext:c-format */ 962 sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start); 963 else 964 /* xgettext:c-format */ 965 sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start); 966 } 967 else 968 { 969 if (strlen (start) > 50) 970 /* xgettext:c-format */ 971 sprintf (errbuf, _("bad instruction `%.50s...'"), start); 972 else 973 /* xgettext:c-format */ 974 sprintf (errbuf, _("bad instruction `%.50s'"), start); 975 } 976 977 *errmsg = errbuf; 978 return NULL; 979 } 980 } 981