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 47static 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 54static const char * MISSING_CLOSING_PARENTHESIS = N_("missing `)'"); 55static const char * INVALID_STORE_RELOC = N_("relocation invalid for store"); 56static const char * INVALID_RELOC_TYPE = N_("internal relocation type invalid"); 57 58#define CGEN_VERBOSE_ASSEMBLER_ERRORS 59 60static const char * 61parse_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 96static const char * 97parse_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 142enum 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 155enum 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 168static 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 225static int 226parse_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 311static const char * 312parse_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 389static const char * 390parse_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 395static const char * 396parse_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 402static const char * 403parse_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 412static const char * 413parse_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 424static const char * 425parse_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 474const 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 490const char * 491or1k_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_RADF : 523 errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_fdr, & fields->f_r2); 524 break; 525 case OR1K_OPERAND_RADI : 526 errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RADI, (unsigned long *) (& fields->f_rad32)); 527 break; 528 case OR1K_OPERAND_RASF : 529 errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_fsr, & fields->f_r2); 530 break; 531 case OR1K_OPERAND_RB : 532 errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_gpr, & fields->f_r3); 533 break; 534 case OR1K_OPERAND_RBD32F : 535 errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RBD32F, (unsigned long *) (& fields->f_rbd32)); 536 break; 537 case OR1K_OPERAND_RBDF : 538 errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_fdr, & fields->f_r3); 539 break; 540 case OR1K_OPERAND_RBDI : 541 errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RBDI, (unsigned long *) (& fields->f_rbd32)); 542 break; 543 case OR1K_OPERAND_RBSF : 544 errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_fsr, & fields->f_r3); 545 break; 546 case OR1K_OPERAND_RD : 547 errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_gpr, & fields->f_r1); 548 break; 549 case OR1K_OPERAND_RDD32F : 550 errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RDD32F, (unsigned long *) (& fields->f_rdd32)); 551 break; 552 case OR1K_OPERAND_RDDF : 553 errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_fdr, & fields->f_r1); 554 break; 555 case OR1K_OPERAND_RDDI : 556 errmsg = parse_regpair (cd, strp, OR1K_OPERAND_RDDI, (unsigned long *) (& fields->f_rdd32)); 557 break; 558 case OR1K_OPERAND_RDSF : 559 errmsg = cgen_parse_keyword (cd, strp, & or1k_cgen_opval_h_fsr, & fields->f_r1); 560 break; 561 case OR1K_OPERAND_SIMM16 : 562 errmsg = parse_simm16 (cd, strp, OR1K_OPERAND_SIMM16, (long *) (& fields->f_simm16)); 563 break; 564 case OR1K_OPERAND_SIMM16_SPLIT : 565 errmsg = parse_simm16_split (cd, strp, OR1K_OPERAND_SIMM16_SPLIT, (long *) (& fields->f_simm16_split)); 566 break; 567 case OR1K_OPERAND_UIMM16 : 568 errmsg = parse_uimm16 (cd, strp, OR1K_OPERAND_UIMM16, (unsigned long *) (& fields->f_uimm16)); 569 break; 570 case OR1K_OPERAND_UIMM16_SPLIT : 571 errmsg = parse_uimm16_split (cd, strp, OR1K_OPERAND_UIMM16_SPLIT, (unsigned long *) (& fields->f_uimm16_split)); 572 break; 573 case OR1K_OPERAND_UIMM6 : 574 errmsg = cgen_parse_unsigned_integer (cd, strp, OR1K_OPERAND_UIMM6, (unsigned long *) (& fields->f_uimm6)); 575 break; 576 577 default : 578 /* xgettext:c-format */ 579 opcodes_error_handler 580 (_("internal error: unrecognized field %d while parsing"), 581 opindex); 582 abort (); 583 } 584 585 return errmsg; 586} 587 588cgen_parse_fn * const or1k_cgen_parse_handlers[] = 589{ 590 parse_insn_normal, 591}; 592 593void 594or1k_cgen_init_asm (CGEN_CPU_DESC cd) 595{ 596 or1k_cgen_init_opcode_table (cd); 597 or1k_cgen_init_ibld_table (cd); 598 cd->parse_handlers = & or1k_cgen_parse_handlers[0]; 599 cd->parse_operand = or1k_cgen_parse_operand; 600#ifdef CGEN_ASM_INIT_HOOK 601CGEN_ASM_INIT_HOOK 602#endif 603} 604 605 606 607/* Regex construction routine. 608 609 This translates an opcode syntax string into a regex string, 610 by replacing any non-character syntax element (such as an 611 opcode) with the pattern '.*' 612 613 It then compiles the regex and stores it in the opcode, for 614 later use by or1k_cgen_assemble_insn 615 616 Returns NULL for success, an error message for failure. */ 617 618char * 619or1k_cgen_build_insn_regex (CGEN_INSN *insn) 620{ 621 CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn); 622 const char *mnem = CGEN_INSN_MNEMONIC (insn); 623 char rxbuf[CGEN_MAX_RX_ELEMENTS]; 624 char *rx = rxbuf; 625 const CGEN_SYNTAX_CHAR_TYPE *syn; 626 int reg_err; 627 628 syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc)); 629 630 /* Mnemonics come first in the syntax string. */ 631 if (! CGEN_SYNTAX_MNEMONIC_P (* syn)) 632 return _("missing mnemonic in syntax string"); 633 ++syn; 634 635 /* Generate a case sensitive regular expression that emulates case 636 insensitive matching in the "C" locale. We cannot generate a case 637 insensitive regular expression because in Turkish locales, 'i' and 'I' 638 are not equal modulo case conversion. */ 639 640 /* Copy the literal mnemonic out of the insn. */ 641 for (; *mnem; mnem++) 642 { 643 char c = *mnem; 644 645 if (ISALPHA (c)) 646 { 647 *rx++ = '['; 648 *rx++ = TOLOWER (c); 649 *rx++ = TOUPPER (c); 650 *rx++ = ']'; 651 } 652 else 653 *rx++ = c; 654 } 655 656 /* Copy any remaining literals from the syntax string into the rx. */ 657 for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn) 658 { 659 if (CGEN_SYNTAX_CHAR_P (* syn)) 660 { 661 char c = CGEN_SYNTAX_CHAR (* syn); 662 663 switch (c) 664 { 665 /* Escape any regex metacharacters in the syntax. */ 666 case '.': case '[': case '\\': 667 case '*': case '^': case '$': 668 669#ifdef CGEN_ESCAPE_EXTENDED_REGEX 670 case '?': case '{': case '}': 671 case '(': case ')': case '*': 672 case '|': case '+': case ']': 673#endif 674 *rx++ = '\\'; 675 *rx++ = c; 676 break; 677 678 default: 679 if (ISALPHA (c)) 680 { 681 *rx++ = '['; 682 *rx++ = TOLOWER (c); 683 *rx++ = TOUPPER (c); 684 *rx++ = ']'; 685 } 686 else 687 *rx++ = c; 688 break; 689 } 690 } 691 else 692 { 693 /* Replace non-syntax fields with globs. */ 694 *rx++ = '.'; 695 *rx++ = '*'; 696 } 697 } 698 699 /* Trailing whitespace ok. */ 700 * rx++ = '['; 701 * rx++ = ' '; 702 * rx++ = '\t'; 703 * rx++ = ']'; 704 * rx++ = '*'; 705 706 /* But anchor it after that. */ 707 * rx++ = '$'; 708 * rx = '\0'; 709 710 CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t)); 711 reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB); 712 713 if (reg_err == 0) 714 return NULL; 715 else 716 { 717 static char msg[80]; 718 719 regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80); 720 regfree ((regex_t *) CGEN_INSN_RX (insn)); 721 free (CGEN_INSN_RX (insn)); 722 (CGEN_INSN_RX (insn)) = NULL; 723 return msg; 724 } 725} 726 727 728/* Default insn parser. 729 730 The syntax string is scanned and operands are parsed and stored in FIELDS. 731 Relocs are queued as we go via other callbacks. 732 733 ??? Note that this is currently an all-or-nothing parser. If we fail to 734 parse the instruction, we return 0 and the caller will start over from 735 the beginning. Backtracking will be necessary in parsing subexpressions, 736 but that can be handled there. Not handling backtracking here may get 737 expensive in the case of the m68k. Deal with later. 738 739 Returns NULL for success, an error message for failure. */ 740 741static const char * 742parse_insn_normal (CGEN_CPU_DESC cd, 743 const CGEN_INSN *insn, 744 const char **strp, 745 CGEN_FIELDS *fields) 746{ 747 /* ??? Runtime added insns not handled yet. */ 748 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn); 749 const char *str = *strp; 750 const char *errmsg; 751 const char *p; 752 const CGEN_SYNTAX_CHAR_TYPE * syn; 753#ifdef CGEN_MNEMONIC_OPERANDS 754 /* FIXME: wip */ 755 int past_opcode_p; 756#endif 757 758 /* For now we assume the mnemonic is first (there are no leading operands). 759 We can parse it without needing to set up operand parsing. 760 GAS's input scrubber will ensure mnemonics are lowercase, but we may 761 not be called from GAS. */ 762 p = CGEN_INSN_MNEMONIC (insn); 763 while (*p && TOLOWER (*p) == TOLOWER (*str)) 764 ++p, ++str; 765 766 if (* p) 767 return _("unrecognized instruction"); 768 769#ifndef CGEN_MNEMONIC_OPERANDS 770 if (* str && ! ISSPACE (* str)) 771 return _("unrecognized instruction"); 772#endif 773 774 CGEN_INIT_PARSE (cd); 775 cgen_init_parse_operand (cd); 776#ifdef CGEN_MNEMONIC_OPERANDS 777 past_opcode_p = 0; 778#endif 779 780 /* We don't check for (*str != '\0') here because we want to parse 781 any trailing fake arguments in the syntax string. */ 782 syn = CGEN_SYNTAX_STRING (syntax); 783 784 /* Mnemonics come first for now, ensure valid string. */ 785 if (! CGEN_SYNTAX_MNEMONIC_P (* syn)) 786 abort (); 787 788 ++syn; 789 790 while (* syn != 0) 791 { 792 /* Non operand chars must match exactly. */ 793 if (CGEN_SYNTAX_CHAR_P (* syn)) 794 { 795 /* FIXME: While we allow for non-GAS callers above, we assume the 796 first char after the mnemonic part is a space. */ 797 /* FIXME: We also take inappropriate advantage of the fact that 798 GAS's input scrubber will remove extraneous blanks. */ 799 if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn))) 800 { 801#ifdef CGEN_MNEMONIC_OPERANDS 802 if (CGEN_SYNTAX_CHAR(* syn) == ' ') 803 past_opcode_p = 1; 804#endif 805 ++ syn; 806 ++ str; 807 } 808 else if (*str) 809 { 810 /* Syntax char didn't match. Can't be this insn. */ 811 static char msg [80]; 812 813 /* xgettext:c-format */ 814 sprintf (msg, _("syntax error (expected char `%c', found `%c')"), 815 CGEN_SYNTAX_CHAR(*syn), *str); 816 return msg; 817 } 818 else 819 { 820 /* Ran out of input. */ 821 static char msg [80]; 822 823 /* xgettext:c-format */ 824 sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"), 825 CGEN_SYNTAX_CHAR(*syn)); 826 return msg; 827 } 828 continue; 829 } 830 831#ifdef CGEN_MNEMONIC_OPERANDS 832 (void) past_opcode_p; 833#endif 834 /* We have an operand of some sort. */ 835 errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields); 836 if (errmsg) 837 return errmsg; 838 839 /* Done with this operand, continue with next one. */ 840 ++ syn; 841 } 842 843 /* If we're at the end of the syntax string, we're done. */ 844 if (* syn == 0) 845 { 846 /* FIXME: For the moment we assume a valid `str' can only contain 847 blanks now. IE: We needn't try again with a longer version of 848 the insn and it is assumed that longer versions of insns appear 849 before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3). */ 850 while (ISSPACE (* str)) 851 ++ str; 852 853 if (* str != '\0') 854 return _("junk at end of line"); /* FIXME: would like to include `str' */ 855 856 return NULL; 857 } 858 859 /* We couldn't parse it. */ 860 return _("unrecognized instruction"); 861} 862 863/* Main entry point. 864 This routine is called for each instruction to be assembled. 865 STR points to the insn to be assembled. 866 We assume all necessary tables have been initialized. 867 The assembled instruction, less any fixups, is stored in BUF. 868 Remember that if CGEN_INT_INSN_P then BUF is an int and thus the value 869 still needs to be converted to target byte order, otherwise BUF is an array 870 of bytes in target byte order. 871 The result is a pointer to the insn's entry in the opcode table, 872 or NULL if an error occured (an error message will have already been 873 printed). 874 875 Note that when processing (non-alias) macro-insns, 876 this function recurses. 877 878 ??? It's possible to make this cpu-independent. 879 One would have to deal with a few minor things. 880 At this point in time doing so would be more of a curiosity than useful 881 [for example this file isn't _that_ big], but keeping the possibility in 882 mind helps keep the design clean. */ 883 884const CGEN_INSN * 885or1k_cgen_assemble_insn (CGEN_CPU_DESC cd, 886 const char *str, 887 CGEN_FIELDS *fields, 888 CGEN_INSN_BYTES_PTR buf, 889 char **errmsg) 890{ 891 const char *start; 892 CGEN_INSN_LIST *ilist; 893 const char *parse_errmsg = NULL; 894 const char *insert_errmsg = NULL; 895 int recognized_mnemonic = 0; 896 897 /* Skip leading white space. */ 898 while (ISSPACE (* str)) 899 ++ str; 900 901 /* The instructions are stored in hashed lists. 902 Get the first in the list. */ 903 ilist = CGEN_ASM_LOOKUP_INSN (cd, str); 904 905 /* Keep looking until we find a match. */ 906 start = str; 907 for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist)) 908 { 909 const CGEN_INSN *insn = ilist->insn; 910 recognized_mnemonic = 1; 911 912#ifdef CGEN_VALIDATE_INSN_SUPPORTED 913 /* Not usually needed as unsupported opcodes 914 shouldn't be in the hash lists. */ 915 /* Is this insn supported by the selected cpu? */ 916 if (! or1k_cgen_insn_supported (cd, insn)) 917 continue; 918#endif 919 /* If the RELAXED attribute is set, this is an insn that shouldn't be 920 chosen immediately. Instead, it is used during assembler/linker 921 relaxation if possible. */ 922 if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED) != 0) 923 continue; 924 925 str = start; 926 927 /* Skip this insn if str doesn't look right lexically. */ 928 if (CGEN_INSN_RX (insn) != NULL && 929 regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH) 930 continue; 931 932 /* Allow parse/insert handlers to obtain length of insn. */ 933 CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn); 934 935 parse_errmsg = CGEN_PARSE_FN (cd, insn) (cd, insn, & str, fields); 936 if (parse_errmsg != NULL) 937 continue; 938 939 /* ??? 0 is passed for `pc'. */ 940 insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf, 941 (bfd_vma) 0); 942 if (insert_errmsg != NULL) 943 continue; 944 945 /* It is up to the caller to actually output the insn and any 946 queued relocs. */ 947 return insn; 948 } 949 950 { 951 static char errbuf[150]; 952 const char *tmp_errmsg; 953#ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS 954#define be_verbose 1 955#else 956#define be_verbose 0 957#endif 958 959 if (be_verbose) 960 { 961 /* If requesting verbose error messages, use insert_errmsg. 962 Failing that, use parse_errmsg. */ 963 tmp_errmsg = (insert_errmsg ? insert_errmsg : 964 parse_errmsg ? parse_errmsg : 965 recognized_mnemonic ? 966 _("unrecognized form of instruction") : 967 _("unrecognized instruction")); 968 969 if (strlen (start) > 50) 970 /* xgettext:c-format */ 971 sprintf (errbuf, "%s `%.50s...'", tmp_errmsg, start); 972 else 973 /* xgettext:c-format */ 974 sprintf (errbuf, "%s `%.50s'", tmp_errmsg, start); 975 } 976 else 977 { 978 if (strlen (start) > 50) 979 /* xgettext:c-format */ 980 sprintf (errbuf, _("bad instruction `%.50s...'"), start); 981 else 982 /* xgettext:c-format */ 983 sprintf (errbuf, _("bad instruction `%.50s'"), start); 984 } 985 986 *errmsg = errbuf; 987 return NULL; 988 } 989} 990