1 /* tc-z8k.c -- Assemble code for the Zilog Z800n 2 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 2000, 2001, 2002, 2003 3 Free Software Foundation, Inc. 4 5 This file is part of GAS, the GNU Assembler. 6 7 GAS is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2, or (at your option) 10 any later version. 11 12 GAS is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GAS; see the file COPYING. If not, write to the Free 19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA 20 02111-1307, USA. */ 21 22 /* Written By Steve Chamberlain <sac@cygnus.com>. */ 23 24 #define DEFINE_TABLE 25 #include <stdio.h> 26 27 #include "as.h" 28 #include "bfd.h" 29 #include "safe-ctype.h" 30 #include "opcodes/z8k-opc.h" 31 32 const char comment_chars[] = "!"; 33 const char line_comment_chars[] = "#"; 34 const char line_separator_chars[] = ";"; 35 36 extern int machine; 37 extern int coff_flags; 38 int segmented_mode; 39 const int md_reloc_size; 40 41 /* This is non-zero if target was set from the command line. */ 42 static int z8k_target_from_cmdline; 43 44 static void 45 s_segm (int segm) 46 { 47 if (segm) 48 { 49 segmented_mode = 1; 50 machine = bfd_mach_z8001; 51 coff_flags = F_Z8001; 52 } 53 else 54 { 55 segmented_mode = 0; 56 machine = bfd_mach_z8002; 57 coff_flags = F_Z8002; 58 } 59 } 60 61 static void 62 even (int ignore ATTRIBUTE_UNUSED) 63 { 64 frag_align (1, 0, 0); 65 record_alignment (now_seg, 1); 66 } 67 68 static int 69 tohex (int c) 70 { 71 if (ISDIGIT (c)) 72 return c - '0'; 73 if (ISLOWER (c)) 74 return c - 'a' + 10; 75 return c - 'A' + 10; 76 } 77 78 static void 79 sval (int ignore ATTRIBUTE_UNUSED) 80 { 81 SKIP_WHITESPACE (); 82 if (*input_line_pointer == '\'') 83 { 84 int c; 85 input_line_pointer++; 86 c = *input_line_pointer++; 87 while (c != '\'') 88 { 89 if (c == '%') 90 { 91 c = (tohex (input_line_pointer[0]) << 4) 92 | tohex (input_line_pointer[1]); 93 input_line_pointer += 2; 94 } 95 FRAG_APPEND_1_CHAR (c); 96 c = *input_line_pointer++; 97 } 98 demand_empty_rest_of_line (); 99 } 100 } 101 102 /* This table describes all the machine specific pseudo-ops the assembler 103 has to support. The fields are: 104 pseudo-op name without dot 105 function to call to execute this pseudo-op 106 Integer arg to pass to the function 107 */ 108 109 const pseudo_typeS md_pseudo_table[] = { 110 {"int" , cons , 2}, 111 {"data.b" , cons , 1}, 112 {"data.w" , cons , 2}, 113 {"data.l" , cons , 4}, 114 {"form" , listing_psize , 0}, 115 {"heading", listing_title , 0}, 116 {"import" , s_ignore , 0}, 117 {"page" , listing_eject , 0}, 118 {"program", s_ignore , 0}, 119 {"z8001" , s_segm , 1}, 120 {"z8002" , s_segm , 0}, 121 122 {"segm" , s_segm , 1}, 123 {"unsegm" , s_segm , 0}, 124 {"unseg" , s_segm , 0}, 125 {"name" , s_app_file , 0}, 126 {"global" , s_globl , 0}, 127 {"wval" , cons , 2}, 128 {"lval" , cons , 4}, 129 {"bval" , cons , 1}, 130 {"sval" , sval , 0}, 131 {"rsect" , obj_coff_section, 0}, 132 {"sect" , obj_coff_section, 0}, 133 {"block" , s_space , 0}, 134 {"even" , even , 0}, 135 {0 , 0 , 0} 136 }; 137 138 const char EXP_CHARS[] = "eE"; 139 140 /* Chars that mean this number is a floating point constant. 141 As in 0f12.456 142 or 0d1.2345e12 */ 143 const char FLT_CHARS[] = "rRsSfFdDxXpP"; 144 145 /* Opcode mnemonics. */ 146 static struct hash_control *opcode_hash_control; 147 148 void 149 md_begin (void) 150 { 151 const opcode_entry_type *opcode; 152 int idx = -1; 153 154 opcode_hash_control = hash_new (); 155 156 for (opcode = z8k_table; opcode->name; opcode++) 157 { 158 /* Only enter unique codes into the table. */ 159 if (idx != opcode->idx) 160 hash_insert (opcode_hash_control, opcode->name, (char *) opcode); 161 idx = opcode->idx; 162 } 163 164 /* Default to z8002. */ 165 if (! z8k_target_from_cmdline) 166 s_segm (0); 167 168 /* Insert the pseudo ops, too. */ 169 for (idx = 0; md_pseudo_table[idx].poc_name; idx++) 170 { 171 opcode_entry_type *fake_opcode; 172 fake_opcode = (opcode_entry_type *) malloc (sizeof (opcode_entry_type)); 173 fake_opcode->name = md_pseudo_table[idx].poc_name; 174 fake_opcode->func = (void *) (md_pseudo_table + idx); 175 fake_opcode->opcode = 250; 176 hash_insert (opcode_hash_control, fake_opcode->name, fake_opcode); 177 } 178 } 179 180 typedef struct z8k_op { 181 /* CLASS_REG_xxx. */ 182 int regsize; 183 184 /* 0 .. 15. */ 185 unsigned int reg; 186 187 int mode; 188 189 /* Any other register associated with the mode. */ 190 unsigned int x_reg; 191 192 /* Any expression. */ 193 expressionS exp; 194 } op_type; 195 196 static expressionS *da_operand; 197 static expressionS *imm_operand; 198 199 static int reg[16]; 200 static int the_cc; 201 static int the_ctrl; 202 static int the_flags; 203 static int the_interrupt; 204 205 static char * 206 whatreg (int *reg, char *src) 207 { 208 if (ISDIGIT (src[1])) 209 { 210 *reg = (src[0] - '0') * 10 + src[1] - '0'; 211 return src + 2; 212 } 213 else 214 { 215 *reg = (src[0] - '0'); 216 return src + 1; 217 } 218 } 219 220 /* Parse operands 221 222 rh0-rh7, rl0-rl7 223 r0-r15 224 rr0-rr14 225 rq0--rq12 226 WREG r0,r1,r2,r3,r4,r5,r6,r7,fp,sp 227 r0l,r0h,..r7l,r7h 228 @WREG 229 @WREG+ 230 @-WREG 231 #const 232 */ 233 234 /* Try to parse a reg name. Return a pointer to the first character 235 in SRC after the reg name. */ 236 237 static char * 238 parse_reg (char *src, int *mode, unsigned int *reg) 239 { 240 char *res = 0; 241 char regno; 242 243 /* Check for stack pointer "sp" alias. */ 244 if ((src[0] == 's' || src[0] == 'S') 245 && (src[1] == 'p' || src[1] == 'P') 246 && (src[2] == 0 || src[2] == ',')) 247 { 248 if (segmented_mode) 249 { 250 *mode = CLASS_REG_LONG; 251 *reg = 14; 252 } 253 else 254 { 255 *mode = CLASS_REG_WORD; 256 *reg = 15; 257 } 258 return src + 2; 259 } 260 261 if (src[0] == 'r' || src[0] == 'R') 262 { 263 if (src[1] == 'r' || src[1] == 'R') 264 { 265 if (src[2] < '0' || src[2] > '9') 266 return res; /* Assume no register name but a label starting with 'rr'. */ 267 *mode = CLASS_REG_LONG; 268 res = whatreg (reg, src + 2); 269 regno = *reg; 270 if (regno > 14) 271 as_bad (_("register rr%d out of range"), regno); 272 if (regno & 1) 273 as_bad (_("register rr%d does not exist"), regno); 274 } 275 else if (src[1] == 'h' || src[1] == 'H') 276 { 277 if (src[2] < '0' || src[2] > '9') 278 return res; /* Assume no register name but a label starting with 'rh'. */ 279 *mode = CLASS_REG_BYTE; 280 res = whatreg (reg, src + 2); 281 regno = *reg; 282 if (regno > 7) 283 as_bad (_("register rh%d out of range"), regno); 284 } 285 else if (src[1] == 'l' || src[1] == 'L') 286 { 287 if (src[2] < '0' || src[2] > '9') 288 return res; /* Assume no register name but a label starting with 'rl'. */ 289 *mode = CLASS_REG_BYTE; 290 res = whatreg (reg, src + 2); 291 regno = *reg; 292 if (regno > 7) 293 as_bad (_("register rl%d out of range"), regno); 294 *reg += 8; 295 } 296 else if (src[1] == 'q' || src[1] == 'Q') 297 { 298 if (src[2] < '0' || src[2] > '9') 299 return res; /* Assume no register name but a label starting with 'rq'. */ 300 *mode = CLASS_REG_QUAD; 301 res = whatreg (reg, src + 2); 302 regno = *reg; 303 if (regno > 12) 304 as_bad (_("register rq%d out of range"), regno); 305 if (regno & 3) 306 as_bad (_("register rq%d does not exist"), regno); 307 } 308 else 309 { 310 if (src[1] < '0' || src[1] > '9') 311 return res; /* Assume no register name but a label starting with 'r'. */ 312 *mode = CLASS_REG_WORD; 313 res = whatreg (reg, src + 1); 314 regno = *reg; 315 if (regno > 15) 316 as_bad (_("register r%d out of range"), regno); 317 } 318 } 319 return res; 320 } 321 322 static char * 323 parse_exp (char *s, expressionS *op) 324 { 325 char *save = input_line_pointer; 326 char *new; 327 328 input_line_pointer = s; 329 expression (op); 330 if (op->X_op == O_absent) 331 as_bad (_("missing operand")); 332 new = input_line_pointer; 333 input_line_pointer = save; 334 return new; 335 } 336 337 /* The many forms of operand: 338 339 <rb> 340 <r> 341 <rr> 342 <rq> 343 @r 344 #exp 345 exp 346 exp(r) 347 r(#exp) 348 r(r) 349 */ 350 351 static char * 352 checkfor (char *ptr, char what) 353 { 354 if (*ptr == what) 355 ptr++; 356 else 357 as_bad (_("expected %c"), what); 358 359 return ptr; 360 } 361 362 /* Make sure the mode supplied is the size of a word. */ 363 364 static void 365 regword (int mode, char *string) 366 { 367 int ok; 368 369 ok = CLASS_REG_WORD; 370 if (ok != mode) 371 { 372 as_bad (_("register is wrong size for a word %s"), string); 373 } 374 } 375 376 /* Make sure the mode supplied is the size of an address. */ 377 378 static void 379 regaddr (int mode, char *string) 380 { 381 int ok; 382 383 ok = segmented_mode ? CLASS_REG_LONG : CLASS_REG_WORD; 384 if (ok != mode) 385 { 386 as_bad (_("register is wrong size for address %s"), string); 387 } 388 } 389 390 struct ctrl_names { 391 int value; 392 char *name; 393 }; 394 395 static struct ctrl_names ctrl_table[] = { 396 { 0x1, "flags" }, /* ldctlb only. */ 397 { 0x2, "fcw" }, /* ldctl only. Applies to all remaining control registers. */ 398 { 0x3, "refresh" }, 399 { 0x4, "psapseg" }, 400 { 0x5, "psapoff" }, 401 { 0x5, "psap" }, 402 { 0x6, "nspseg" }, 403 { 0x7, "nspoff" }, 404 { 0x7, "nsp" }, 405 { 0 , 0 } 406 }; 407 408 static void 409 get_ctrl_operand (char **ptr, struct z8k_op *mode, unsigned int dst ATTRIBUTE_UNUSED) 410 { 411 char *src = *ptr; 412 int i, l; 413 414 while (*src == ' ') 415 src++; 416 417 mode->mode = CLASS_CTRL; 418 for (i = 0; ctrl_table[i].name; i++) 419 { 420 l = strlen (ctrl_table[i].name); 421 if (! strncasecmp (ctrl_table[i].name, src, l)) 422 { 423 the_ctrl = ctrl_table[i].value; 424 if (*(src + l) && *(src + l) != ',') 425 break; 426 *ptr = src + l; /* Valid control name found: "consume" it. */ 427 return; 428 } 429 } 430 the_ctrl = 0; 431 } 432 433 struct flag_names { 434 int value; 435 char *name; 436 }; 437 438 static struct flag_names flag_table[] = { 439 { 0x1, "P" }, 440 { 0x1, "V" }, 441 { 0x2, "S" }, 442 { 0x4, "Z" }, 443 { 0x8, "C" }, 444 { 0x0, "+" }, 445 { 0x0, "," }, 446 { 0, 0 } 447 }; 448 449 static void 450 get_flags_operand (char **ptr, struct z8k_op *mode, unsigned int dst ATTRIBUTE_UNUSED) 451 { 452 char *src = *ptr; 453 char c; 454 int i; 455 int j; 456 457 while (*src == ' ') 458 src++; 459 460 mode->mode = CLASS_FLAGS; 461 the_flags = 0; 462 for (j = 0; j <= 9; j++) 463 { 464 if (!src[j]) 465 goto done; 466 c = TOUPPER(src[j]); 467 for (i = 0; flag_table[i].name; i++) 468 { 469 if (flag_table[i].name[0] == c) 470 { 471 the_flags = the_flags | flag_table[i].value; 472 goto match; 473 } 474 } 475 goto done; 476 match: 477 ; 478 } 479 done: 480 *ptr = src + j; 481 } 482 483 struct interrupt_names { 484 int value; 485 char *name; 486 }; 487 488 static struct interrupt_names intr_table[] = { 489 { 0x1, "nvi" }, 490 { 0x2, "vi" }, 491 { 0x3, "both" }, 492 { 0x3, "all" }, 493 { 0, 0 } 494 }; 495 496 static void 497 get_interrupt_operand (char **ptr, struct z8k_op *mode, unsigned int dst ATTRIBUTE_UNUSED) 498 { 499 char *src = *ptr; 500 int i, l; 501 502 while (*src == ' ') 503 src++; 504 505 mode->mode = CLASS_IMM; 506 the_interrupt = 0; 507 508 while (*src) 509 { 510 for (i = 0; intr_table[i].name; i++) 511 { 512 l = strlen (intr_table[i].name); 513 if (! strncasecmp (intr_table[i].name, src, l)) 514 { 515 the_interrupt |= intr_table[i].value; 516 if (*(src + l) && *(src + l) != ',') 517 { 518 *ptr = src + l; 519 invalid: 520 as_bad (_("unknown interrupt %s"), src); 521 while (**ptr && ! is_end_of_line[(unsigned char) **ptr]) 522 (*ptr)++; /* Consume rest of line. */ 523 return; 524 } 525 src += l; 526 if (! *src) 527 { 528 *ptr = src; 529 return; 530 } 531 } 532 } 533 if (*src == ',') 534 src++; 535 else 536 { 537 *ptr = src; 538 goto invalid; 539 } 540 } 541 542 /* No interrupt type specified, opcode won't do anything. */ 543 as_warn (_("opcode has no effect")); 544 the_interrupt = 0x0; 545 } 546 547 struct cc_names { 548 int value; 549 char *name; 550 }; 551 552 static struct cc_names table[] = { 553 { 0x0, "f" }, 554 { 0x1, "lt" }, 555 { 0x2, "le" }, 556 { 0x3, "ule" }, 557 { 0x4, "ov/pe" }, 558 { 0x4, "ov" }, 559 { 0x4, "pe/ov" }, 560 { 0x4, "pe" }, 561 { 0x5, "mi" }, 562 { 0x6, "eq" }, 563 { 0x6, "z" }, 564 { 0x7, "c/ult" }, 565 { 0x7, "c" }, 566 { 0x7, "ult/c" }, 567 { 0x7, "ult" }, 568 { 0x8, "t" }, 569 { 0x9, "ge" }, 570 { 0xa, "gt" }, 571 { 0xb, "ugt" }, 572 { 0xc, "nov/po" }, 573 { 0xc, "nov" }, 574 { 0xc, "po/nov" }, 575 { 0xc, "po" }, 576 { 0xd, "pl" }, 577 { 0xe, "ne" }, 578 { 0xe, "nz" }, 579 { 0xf, "nc/uge" }, 580 { 0xf, "nc" }, 581 { 0xf, "uge/nc" }, 582 { 0xf, "uge" }, 583 { 0 , 0 } 584 }; 585 586 static void 587 get_cc_operand (char **ptr, struct z8k_op *mode, unsigned int dst ATTRIBUTE_UNUSED) 588 { 589 char *src = *ptr; 590 int i, l; 591 592 while (*src == ' ') 593 src++; 594 595 mode->mode = CLASS_CC; 596 for (i = 0; table[i].name; i++) 597 { 598 l = strlen (table[i].name); 599 if (! strncasecmp (table[i].name, src, l)) 600 { 601 the_cc = table[i].value; 602 if (*(src + l) && *(src + l) != ',') 603 break; 604 *ptr = src + l; /* Valid cc found: "consume" it. */ 605 return; 606 } 607 } 608 the_cc = 0x8; /* Not recognizing the cc defaults to t. (Assuming no cc present.) */ 609 } 610 611 static void 612 get_operand (char **ptr, struct z8k_op *mode, unsigned int dst ATTRIBUTE_UNUSED) 613 { 614 char *src = *ptr; 615 char *end; 616 617 mode->mode = 0; 618 619 while (*src == ' ') 620 src++; 621 if (*src == '#') 622 { 623 mode->mode = CLASS_IMM; 624 imm_operand = &(mode->exp); 625 src = parse_exp (src + 1, &(mode->exp)); 626 } 627 else if (*src == '@') 628 { 629 mode->mode = CLASS_IR; 630 src = parse_reg (src + 1, &mode->regsize, &mode->reg); 631 } 632 else 633 { 634 int regn; 635 636 end = parse_reg (src, &mode->mode, ®n); 637 638 if (end) 639 { 640 int nw, nr; 641 642 src = end; 643 if (*src == '(') 644 { 645 src++; 646 end = parse_reg (src, &nw, &nr); 647 if (end) 648 { 649 /* Got Ra(Rb). */ 650 src = end; 651 652 if (*src != ')') 653 as_bad (_("Missing ) in ra(rb)")); 654 else 655 src++; 656 657 regaddr (mode->mode, "ra(rb) ra"); 658 #if 0 659 regword (mode->mode, "ra(rb) rb"); 660 #endif 661 mode->mode = CLASS_BX; 662 mode->reg = regn; 663 mode->x_reg = nr; 664 reg[ARG_RX] = nr; 665 } 666 else 667 { 668 /* Got Ra(disp). */ 669 if (*src == '#') 670 src++; 671 src = parse_exp (src, &(mode->exp)); 672 src = checkfor (src, ')'); 673 mode->mode = CLASS_BA; 674 mode->reg = regn; 675 mode->x_reg = 0; 676 imm_operand = &(mode->exp); 677 } 678 } 679 else 680 { 681 mode->reg = regn; 682 mode->x_reg = 0; 683 } 684 } 685 else 686 { 687 /* No initial reg. */ 688 src = parse_exp (src, &(mode->exp)); 689 if (*src == '(') 690 { 691 src++; 692 end = parse_reg (src, &(mode->mode), ®n); 693 regword (mode->mode, "addr(Ra) ra"); 694 mode->mode = CLASS_X; 695 mode->reg = regn; 696 mode->x_reg = 0; 697 da_operand = &(mode->exp); 698 src = checkfor (end, ')'); 699 } 700 else 701 { 702 /* Just an address. */ 703 mode->mode = CLASS_DA; 704 mode->reg = 0; 705 mode->x_reg = 0; 706 da_operand = &(mode->exp); 707 } 708 } 709 } 710 *ptr = src; 711 } 712 713 static char * 714 get_operands (const opcode_entry_type *opcode, char *op_end, op_type *operand) 715 { 716 char *ptr = op_end; 717 char *savptr; 718 719 switch (opcode->noperands) 720 { 721 case 0: 722 operand[0].mode = 0; 723 operand[1].mode = 0; 724 while (*ptr == ' ') 725 ptr++; 726 break; 727 728 case 1: 729 if (opcode->arg_info[0] == CLASS_CC) 730 { 731 get_cc_operand (&ptr, operand + 0, 0); 732 while (*ptr == ' ') 733 ptr++; 734 if (*ptr && ! is_end_of_line[(unsigned char) *ptr]) 735 { 736 as_bad (_("invalid condition code '%s'"), ptr); 737 while (*ptr && ! is_end_of_line[(unsigned char) *ptr]) 738 ptr++; /* Consume rest of line. */ 739 } 740 } 741 else if (opcode->arg_info[0] == CLASS_FLAGS) 742 { 743 get_flags_operand (&ptr, operand + 0, 0); 744 while (*ptr == ' ') 745 ptr++; 746 if (*ptr && ! is_end_of_line[(unsigned char) *ptr]) 747 { 748 as_bad (_("invalid flag '%s'"), ptr); 749 while (*ptr && ! is_end_of_line[(unsigned char) *ptr]) 750 ptr++; /* Consume rest of line. */ 751 } 752 } 753 else if (opcode->arg_info[0] == (CLASS_IMM + (ARG_IMM2))) 754 get_interrupt_operand (&ptr, operand + 0, 0); 755 else 756 get_operand (&ptr, operand + 0, 0); 757 758 operand[1].mode = 0; 759 break; 760 761 case 2: 762 savptr = ptr; 763 if (opcode->arg_info[0] == CLASS_CC) 764 { 765 get_cc_operand (&ptr, operand + 0, 0); 766 while (*ptr == ' ') 767 ptr++; 768 if (*ptr != ',' && strchr (ptr + 1, ',')) 769 { 770 savptr = ptr; 771 while (*ptr != ',') 772 ptr++; 773 *ptr = 0; 774 ptr++; 775 as_bad (_("invalid condition code '%s'"), savptr); 776 } 777 } 778 else if (opcode->arg_info[0] == CLASS_CTRL) 779 { 780 get_ctrl_operand (&ptr, operand + 0, 0); 781 782 if (the_ctrl == 0) 783 { 784 ptr = savptr; 785 get_operand (&ptr, operand + 0, 0); 786 787 if (ptr == 0) 788 return NULL; 789 if (*ptr == ',') 790 ptr++; 791 get_ctrl_operand (&ptr, operand + 1, 1); 792 if (the_ctrl == 0) 793 return NULL; 794 return ptr; 795 } 796 } 797 else 798 get_operand (&ptr, operand + 0, 0); 799 800 if (ptr == 0) 801 return NULL; 802 if (*ptr == ',') 803 ptr++; 804 get_operand (&ptr, operand + 1, 1); 805 break; 806 807 case 3: 808 get_operand (&ptr, operand + 0, 0); 809 if (*ptr == ',') 810 ptr++; 811 get_operand (&ptr, operand + 1, 1); 812 if (*ptr == ',') 813 ptr++; 814 get_operand (&ptr, operand + 2, 2); 815 break; 816 817 case 4: 818 get_operand (&ptr, operand + 0, 0); 819 if (*ptr == ',') 820 ptr++; 821 get_operand (&ptr, operand + 1, 1); 822 if (*ptr == ',') 823 ptr++; 824 get_operand (&ptr, operand + 2, 2); 825 if (*ptr == ',') 826 ptr++; 827 get_cc_operand (&ptr, operand + 3, 3); 828 break; 829 830 default: 831 abort (); 832 } 833 834 return ptr; 835 } 836 837 /* Passed a pointer to a list of opcodes which use different 838 addressing modes. Return the opcode which matches the opcodes 839 provided. */ 840 841 static opcode_entry_type * 842 get_specific (opcode_entry_type *opcode, op_type *operands) 843 { 844 opcode_entry_type *this_try = opcode; 845 int found = 0; 846 unsigned int noperands = opcode->noperands; 847 848 int this_index = opcode->idx; 849 850 while (this_index == opcode->idx && !found) 851 { 852 unsigned int i; 853 854 this_try = opcode++; 855 for (i = 0; i < noperands; i++) 856 { 857 unsigned int mode = operands[i].mode; 858 859 if (((mode & CLASS_MASK) == CLASS_IR) && ((this_try->arg_info[i] & CLASS_MASK) == CLASS_IRO)) 860 { 861 mode = operands[i].mode = (operands[i].mode & ~CLASS_MASK) | CLASS_IRO; 862 } 863 864 if ((mode & CLASS_MASK) != (this_try->arg_info[i] & CLASS_MASK)) 865 { 866 /* It could be a pc rel operand, if this is a da mode 867 and we like disps, then insert it. */ 868 869 if (mode == CLASS_DA && this_try->arg_info[i] == CLASS_DISP) 870 { 871 /* This is the case. */ 872 operands[i].mode = CLASS_DISP; 873 } 874 else if (mode == CLASS_BA && this_try->arg_info[i]) 875 { 876 /* Can't think of a way to turn what we've been 877 given into something that's OK. */ 878 goto fail; 879 } 880 else if (this_try->arg_info[i] & CLASS_PR) 881 { 882 if (mode == CLASS_REG_LONG && segmented_mode) 883 { 884 /* OK. */ 885 } 886 else if (mode == CLASS_REG_WORD && !segmented_mode) 887 { 888 /* OK. */ 889 } 890 else 891 goto fail; 892 } 893 else 894 goto fail; 895 } 896 switch (mode & CLASS_MASK) 897 { 898 default: 899 break; 900 case CLASS_IRO: 901 if (operands[i].regsize != CLASS_REG_WORD) 902 as_bad (_("invalid indirect register size")); 903 reg[this_try->arg_info[i] & ARG_MASK] = operands[i].reg; 904 break; 905 case CLASS_IR: 906 if ((segmented_mode && operands[i].regsize != CLASS_REG_LONG) 907 || (!segmented_mode && operands[i].regsize != CLASS_REG_WORD)) 908 as_bad (_("invalid indirect register size")); 909 reg[this_try->arg_info[i] & ARG_MASK] = operands[i].reg; 910 break; 911 case CLASS_X: 912 case CLASS_BA: 913 case CLASS_BX: 914 case CLASS_DISP: 915 case CLASS_REG: 916 case CLASS_REG_WORD: 917 case CLASS_REG_BYTE: 918 case CLASS_REG_QUAD: 919 case CLASS_REG_LONG: 920 case CLASS_REGN0: 921 reg[this_try->arg_info[i] & ARG_MASK] = operands[i].reg; 922 break; 923 case CLASS_CTRL: 924 if (this_try->opcode == OPC_ldctlb && the_ctrl != 1) 925 as_bad (_("invalid control register name")); 926 break; 927 } 928 } 929 930 found = 1; 931 fail: 932 ; 933 } 934 if (found) 935 return this_try; 936 else 937 return 0; 938 } 939 940 static char buffer[20]; 941 942 static void 943 newfix (int ptr, int type, int size, expressionS *operand) 944 { 945 int is_pcrel = 0; 946 947 /* size is in nibbles. */ 948 949 if (operand->X_add_symbol 950 || operand->X_op_symbol 951 || operand->X_add_number) 952 { 953 switch(type) 954 { 955 case R_JR: 956 case R_DISP7: 957 case R_CALLR: 958 is_pcrel = 1; 959 } 960 fix_new_exp (frag_now, 961 ptr, 962 size / 2, 963 operand, 964 is_pcrel, 965 type); 966 } 967 } 968 969 static char * 970 apply_fix (char *ptr, int type, expressionS *operand, int size) 971 { 972 long n = operand->X_add_number; 973 974 /* size is in nibbles. */ 975 976 newfix ((ptr - buffer) / 2, type, size + 1, operand); 977 switch (size) 978 { 979 case 8: /* 8 nibbles == 32 bits. */ 980 *ptr++ = n >> 28; 981 *ptr++ = n >> 24; 982 *ptr++ = n >> 20; 983 *ptr++ = n >> 16; 984 case 4: /* 4 nibbles == 16 bits. */ 985 *ptr++ = n >> 12; 986 *ptr++ = n >> 8; 987 case 2: 988 *ptr++ = n >> 4; 989 case 1: 990 *ptr++ = n >> 0; 991 break; 992 } 993 return ptr; 994 } 995 996 /* Now we know what sort of opcodes it is. Let's build the bytes. */ 997 998 #define INSERT(x,y) *x++ = y>>24; *x++ = y>> 16; *x++=y>>8; *x++ =y; 999 1000 static void 1001 build_bytes (opcode_entry_type *this_try, struct z8k_op *operand ATTRIBUTE_UNUSED) 1002 { 1003 char *output_ptr = buffer; 1004 int c; 1005 int nibble; 1006 unsigned int *class_ptr; 1007 1008 frag_wane (frag_now); 1009 frag_new (0); 1010 1011 memset (buffer, 0, sizeof (buffer)); 1012 class_ptr = this_try->byte_info; 1013 1014 for (nibble = 0; (c = *class_ptr++); nibble++) 1015 { 1016 1017 switch (c & CLASS_MASK) 1018 { 1019 default: 1020 abort (); 1021 1022 case CLASS_ADDRESS: 1023 /* Direct address, we don't cope with the SS mode right now. */ 1024 if (segmented_mode) 1025 { 1026 /* da_operand->X_add_number |= 0x80000000; -- Now set at relocation time. */ 1027 output_ptr = apply_fix (output_ptr, R_IMM32, da_operand, 8); 1028 } 1029 else 1030 { 1031 output_ptr = apply_fix (output_ptr, R_IMM16, da_operand, 4); 1032 } 1033 da_operand = 0; 1034 break; 1035 case CLASS_DISP8: 1036 /* pc rel 8 bit */ 1037 output_ptr = apply_fix (output_ptr, R_JR, da_operand, 2); 1038 da_operand = 0; 1039 break; 1040 1041 case CLASS_0DISP7: 1042 /* pc rel 7 bit */ 1043 *output_ptr = 0; 1044 output_ptr = apply_fix (output_ptr, R_DISP7, da_operand, 2); 1045 da_operand = 0; 1046 break; 1047 1048 case CLASS_1DISP7: 1049 /* pc rel 7 bit */ 1050 *output_ptr = 0x80; 1051 output_ptr = apply_fix (output_ptr, R_DISP7, da_operand, 2); 1052 output_ptr[-2] = 0x8; 1053 da_operand = 0; 1054 break; 1055 1056 case CLASS_BIT_1OR2: 1057 *output_ptr = c & 0xf; 1058 if (imm_operand) 1059 { 1060 if (imm_operand->X_add_number == 2) 1061 *output_ptr |= 2; 1062 else if (imm_operand->X_add_number != 1) 1063 as_bad (_("immediate must be 1 or 2")); 1064 } 1065 else 1066 as_bad (_("immediate 1 or 2 expected")); 1067 output_ptr++; 1068 break; 1069 case CLASS_CC: 1070 *output_ptr++ = the_cc; 1071 break; 1072 case CLASS_0CCC: 1073 if (the_ctrl < 2 || the_ctrl > 7) 1074 as_bad (_("invalid control register name")); 1075 *output_ptr++ = the_ctrl; 1076 break; 1077 case CLASS_1CCC: 1078 if (the_ctrl < 2 || the_ctrl > 7) 1079 as_bad (_("invalid control register name")); 1080 *output_ptr++ = the_ctrl | 0x8; 1081 break; 1082 case CLASS_00II: 1083 *output_ptr++ = (~the_interrupt & 0x3); 1084 break; 1085 case CLASS_01II: 1086 *output_ptr++ = (~the_interrupt & 0x3) | 0x4; 1087 break; 1088 case CLASS_FLAGS: 1089 *output_ptr++ = the_flags; 1090 break; 1091 case CLASS_IGNORE: 1092 case CLASS_BIT: 1093 *output_ptr++ = c & 0xf; 1094 break; 1095 case CLASS_REGN0: 1096 if (reg[c & 0xf] == 0) 1097 as_bad (_("can't use R0 here")); 1098 /* Fall through. */ 1099 case CLASS_REG: 1100 case CLASS_REG_BYTE: 1101 case CLASS_REG_WORD: 1102 case CLASS_REG_LONG: 1103 case CLASS_REG_QUAD: 1104 /* Insert bit mattern of right reg. */ 1105 *output_ptr++ = reg[c & 0xf]; 1106 break; 1107 case CLASS_DISP: 1108 switch (c & ARG_MASK) 1109 { 1110 case ARG_DISP12: 1111 output_ptr = apply_fix (output_ptr, R_CALLR, da_operand, 4); 1112 break; 1113 case ARG_DISP16: 1114 output_ptr = apply_fix (output_ptr, R_REL16, da_operand, 4); 1115 break; 1116 default: 1117 output_ptr = apply_fix (output_ptr, R_IMM16, da_operand, 4); 1118 } 1119 da_operand = 0; 1120 break; 1121 1122 case CLASS_IMM: 1123 { 1124 switch (c & ARG_MASK) 1125 { 1126 case ARG_NIM4: 1127 if (imm_operand->X_add_number > 15) 1128 { 1129 as_bad (_("immediate value out of range")); 1130 } 1131 imm_operand->X_add_number = -imm_operand->X_add_number; 1132 output_ptr = apply_fix (output_ptr, R_IMM4L, imm_operand, 1); 1133 break; 1134 /*case ARG_IMMNMINUS1: not used. */ 1135 case ARG_IMM4M1: 1136 imm_operand->X_add_number--; 1137 /* Drop through. */ 1138 case ARG_IMM4: 1139 if (imm_operand->X_add_number > 15) 1140 { 1141 as_bad (_("immediate value out of range")); 1142 } 1143 output_ptr = apply_fix (output_ptr, R_IMM4L, imm_operand, 1); 1144 break; 1145 case ARG_NIM8: 1146 imm_operand->X_add_number = -imm_operand->X_add_number; 1147 /* Drop through. */ 1148 case ARG_IMM8: 1149 output_ptr = apply_fix (output_ptr, R_IMM8, imm_operand, 2); 1150 break; 1151 case ARG_IMM16: 1152 output_ptr = apply_fix (output_ptr, R_IMM16, imm_operand, 4); 1153 break; 1154 case ARG_IMM32: 1155 output_ptr = apply_fix (output_ptr, R_IMM32, imm_operand, 8); 1156 break; 1157 default: 1158 abort (); 1159 } 1160 } 1161 } 1162 } 1163 1164 /* Copy from the nibble buffer into the frag. */ 1165 { 1166 int length = (output_ptr - buffer) / 2; 1167 char *src = buffer; 1168 char *fragp = frag_more (length); 1169 1170 while (src < output_ptr) 1171 { 1172 *fragp = (src[0] << 4) | src[1]; 1173 src += 2; 1174 fragp++; 1175 } 1176 } 1177 } 1178 1179 /* This is the guts of the machine-dependent assembler. STR points to a 1180 machine dependent instruction. This function is supposed to emit 1181 the frags/bytes it assembles to. */ 1182 1183 void 1184 md_assemble (char *str) 1185 { 1186 char c; 1187 char *op_start; 1188 char *op_end; 1189 struct z8k_op operand[3]; 1190 opcode_entry_type *opcode; 1191 1192 /* Drop leading whitespace. */ 1193 while (*str == ' ') 1194 str++; 1195 1196 /* Find the op code end. */ 1197 for (op_start = op_end = str; 1198 *op_end != 0 && *op_end != ' ' && ! is_end_of_line[(unsigned char) *op_end]; 1199 op_end++) 1200 ; 1201 1202 if (op_end == op_start) 1203 { 1204 as_bad (_("can't find opcode ")); 1205 } 1206 c = *op_end; 1207 1208 *op_end = 0; /* Zero-terminate op code string for hash_find() call. */ 1209 1210 opcode = (opcode_entry_type *) hash_find (opcode_hash_control, op_start); 1211 1212 if (opcode == NULL) 1213 { 1214 as_bad (_("unknown opcode")); 1215 return; 1216 } 1217 1218 *op_end = c; /* Restore original string. */ 1219 1220 if (opcode->opcode == 250) 1221 { 1222 pseudo_typeS *p; 1223 char oc; 1224 char *old = input_line_pointer; 1225 1226 /* Was really a pseudo op. */ 1227 1228 input_line_pointer = op_end; 1229 1230 oc = *old; 1231 *old = '\n'; 1232 while (*input_line_pointer == ' ') 1233 input_line_pointer++; 1234 p = (pseudo_typeS *) (opcode->func); 1235 1236 (p->poc_handler) (p->poc_val); 1237 input_line_pointer = old; 1238 *old = oc; 1239 } 1240 else 1241 { 1242 char *new_input_line_pointer; 1243 1244 new_input_line_pointer = get_operands (opcode, op_end, operand); 1245 if (new_input_line_pointer) 1246 input_line_pointer = new_input_line_pointer; 1247 1248 opcode = get_specific (opcode, operand); 1249 1250 if (opcode == 0) 1251 { 1252 /* Couldn't find an opcode which matched the operands. */ 1253 char *where = frag_more (2); 1254 1255 where[0] = 0x0; 1256 where[1] = 0x0; 1257 1258 as_bad (_("Can't find opcode to match operands")); 1259 return; 1260 } 1261 1262 build_bytes (opcode, operand); 1263 } 1264 } 1265 1266 void 1267 tc_crawl_symbol_chain (object_headers *headers ATTRIBUTE_UNUSED) 1268 { 1269 printf (_("call to tc_crawl_symbol_chain \n")); 1270 } 1271 1272 /* We have no need to default values of symbols. */ 1273 1274 symbolS * 1275 md_undefined_symbol (char *name ATTRIBUTE_UNUSED) 1276 { 1277 return 0; 1278 } 1279 1280 void 1281 tc_headers_hook (object_headers *headers ATTRIBUTE_UNUSED) 1282 { 1283 printf (_("call to tc_headers_hook \n")); 1284 } 1285 1286 /* Various routines to kill one day. */ 1287 /* Equal to MAX_PRECISION in atof-ieee.c. */ 1288 #define MAX_LITTLENUMS 6 1289 1290 /* Turn a string in input_line_pointer into a floating point constant 1291 of type TYPE, and store the appropriate bytes in *LITP. The number 1292 of LITTLENUMS emitted is stored in *SIZEP. An error message is 1293 returned, or NULL on OK. */ 1294 1295 char * 1296 md_atof (int type, char *litP, int *sizeP) 1297 { 1298 int prec; 1299 LITTLENUM_TYPE words[MAX_LITTLENUMS]; 1300 LITTLENUM_TYPE *wordP; 1301 char *t; 1302 1303 switch (type) 1304 { 1305 case 'f': 1306 case 'F': 1307 case 's': 1308 case 'S': 1309 prec = 2; 1310 break; 1311 1312 case 'd': 1313 case 'D': 1314 case 'r': 1315 case 'R': 1316 prec = 4; 1317 break; 1318 1319 case 'x': 1320 case 'X': 1321 prec = 6; 1322 break; 1323 1324 case 'p': 1325 case 'P': 1326 prec = 6; 1327 break; 1328 1329 default: 1330 *sizeP = 0; 1331 return _("Bad call to MD_ATOF()"); 1332 } 1333 t = atof_ieee (input_line_pointer, type, words); 1334 if (t) 1335 input_line_pointer = t; 1336 1337 *sizeP = prec * sizeof (LITTLENUM_TYPE); 1338 for (wordP = words; prec--;) 1339 { 1340 md_number_to_chars (litP, (long) (*wordP++), sizeof (LITTLENUM_TYPE)); 1341 litP += sizeof (LITTLENUM_TYPE); 1342 } 1343 return 0; 1344 } 1345 1346 const char *md_shortopts = "z:"; 1347 1348 struct option md_longopts[] = 1349 { 1350 #define OPTION_RELAX (OPTION_MD_BASE) 1351 {"linkrelax", no_argument, NULL, OPTION_RELAX}, 1352 {NULL, no_argument, NULL, 0} 1353 }; 1354 1355 size_t md_longopts_size = sizeof (md_longopts); 1356 1357 int 1358 md_parse_option (int c, char *arg) 1359 { 1360 switch (c) 1361 { 1362 case 'z': 1363 if (!strcmp (arg, "8001")) 1364 s_segm (1); 1365 else if (!strcmp (arg, "8002")) 1366 s_segm (0); 1367 else 1368 { 1369 as_bad (_("invalid architecture -z%s"), arg); 1370 return 0; 1371 } 1372 z8k_target_from_cmdline = 1; 1373 break; 1374 1375 case OPTION_RELAX: 1376 linkrelax = 1; 1377 break; 1378 1379 default: 1380 return 0; 1381 } 1382 1383 return 1; 1384 } 1385 1386 void 1387 md_show_usage (FILE *stream) 1388 { 1389 fprintf (stream, _("\ 1390 Z8K options:\n\ 1391 -z8001 generate segmented code\n\ 1392 -z8002 generate unsegmented code\n\ 1393 -linkrelax create linker relaxable code\n")); 1394 } 1395 1396 void 1397 md_convert_frag (object_headers *headers ATTRIBUTE_UNUSED, 1398 segT seg ATTRIBUTE_UNUSED, 1399 fragS *fragP ATTRIBUTE_UNUSED) 1400 { 1401 printf (_("call to md_convert_frag\n")); 1402 abort (); 1403 } 1404 1405 valueT 1406 md_section_align (segT seg, valueT size) 1407 { 1408 return ((size + (1 << section_alignment[(int) seg]) - 1) 1409 & (-1 << section_alignment[(int) seg])); 1410 } 1411 1412 /* Attempt to simplify or eliminate a fixup. To indicate that a fixup 1413 has been eliminated, set fix->fx_done. If fix->fx_addsy is non-NULL, 1414 we will have to generate a reloc entry. */ 1415 void 1416 md_apply_fix3 (fixS *fixP, valueT *valP, segT segment ATTRIBUTE_UNUSED) 1417 { 1418 long val = * (long *) valP; 1419 char *buf = fixP->fx_where + fixP->fx_frag->fr_literal; 1420 1421 switch (fixP->fx_r_type) 1422 { 1423 case R_IMM4L: 1424 buf[0] = (buf[0] & 0xf0) | (val & 0xf); 1425 break; 1426 1427 case R_JR: 1428 if (fixP->fx_addsy) 1429 { 1430 fixP->fx_no_overflow = 1; 1431 fixP->fx_done = 0; 1432 } 1433 else 1434 { 1435 if (val & 1) 1436 as_bad (_("cannot branch to odd address")); 1437 val /= 2; 1438 if (val > 127 || val < -128) 1439 as_warn (_("relative jump out of range")); 1440 *buf++ = val; 1441 fixP->fx_no_overflow = 1; 1442 fixP->fx_done = 1; 1443 } 1444 break; 1445 1446 case R_DISP7: 1447 if (fixP->fx_addsy) 1448 { 1449 fixP->fx_no_overflow = 1; 1450 fixP->fx_done = 0; 1451 } 1452 else 1453 { 1454 if (val & 1) 1455 as_bad (_("cannot branch to odd address")); 1456 val /= 2; 1457 if (val > 0 || val < -127) 1458 as_bad (_("relative jump out of range")); 1459 *buf = (*buf & 0x80) | (-val & 0x7f); 1460 fixP->fx_no_overflow = 1; 1461 fixP->fx_done = 1; 1462 } 1463 break; 1464 1465 case R_CALLR: 1466 if (fixP->fx_addsy) 1467 { 1468 fixP->fx_no_overflow = 1; 1469 fixP->fx_done = 0; 1470 } 1471 else 1472 { 1473 if (val & 1) 1474 as_bad (_("cannot branch to odd address")); 1475 if (val > 4096 || val < -4095) 1476 as_bad (_("relative call out of range")); 1477 val = -val / 2; 1478 *buf = (*buf & 0xf0) | ((val >> 8) & 0xf); 1479 buf++; 1480 *buf++ = val & 0xff; 1481 fixP->fx_no_overflow = 1; 1482 fixP->fx_done = 1; 1483 } 1484 break; 1485 1486 case R_IMM8: 1487 *buf++ = val; 1488 break; 1489 1490 case R_IMM16: 1491 *buf++ = (val >> 8); 1492 *buf++ = val; 1493 break; 1494 1495 case R_IMM32: 1496 *buf++ = (val >> 24); 1497 *buf++ = (val >> 16); 1498 *buf++ = (val >> 8); 1499 *buf++ = val; 1500 break; 1501 1502 case R_REL16: 1503 val = val - fixP->fx_frag->fr_address + fixP->fx_where - fixP->fx_size; 1504 if (val > 32767 || val < -32768) 1505 as_bad (_("relative address out of range")); 1506 *buf++ = (val >> 8); 1507 *buf++ = val; 1508 fixP->fx_no_overflow = 1; 1509 break; 1510 1511 #if 0 1512 case R_DA | R_SEG: 1513 *buf++ = (val >> 16); 1514 *buf++ = 0x00; 1515 *buf++ = (val >> 8); 1516 *buf++ = val; 1517 break; 1518 #endif 1519 1520 case 0: 1521 md_number_to_chars (buf, val, fixP->fx_size); 1522 break; 1523 1524 default: 1525 printf(_("md_apply_fix3: unknown r_type 0x%x\n"), fixP->fx_r_type); 1526 abort (); 1527 } 1528 1529 if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0) 1530 fixP->fx_done = 1; 1531 } 1532 1533 int 1534 md_estimate_size_before_relax (fragS *fragP ATTRIBUTE_UNUSED, 1535 segT segment_type ATTRIBUTE_UNUSED) 1536 { 1537 printf (_("call to md_estimate_size_before_relax\n")); 1538 abort (); 1539 } 1540 1541 /* Put number into target byte order. */ 1542 1543 void 1544 md_number_to_chars (char *ptr, valueT use, int nbytes) 1545 { 1546 number_to_chars_bigendian (ptr, use, nbytes); 1547 } 1548 1549 /* On the Z8000, a PC-relative offset is relative to the address of the 1550 instruction plus its size. */ 1551 long 1552 md_pcrel_from (fixS *fixP) 1553 { 1554 return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address; 1555 } 1556 1557 void 1558 tc_coff_symbol_emit_hook (symbolS *s ATTRIBUTE_UNUSED) 1559 { 1560 } 1561 1562 void 1563 tc_reloc_mangle (fixS *fix_ptr, struct internal_reloc *intr, bfd_vma base) 1564 { 1565 symbolS *symbol_ptr; 1566 1567 if (fix_ptr->fx_addsy 1568 && fix_ptr->fx_subsy) 1569 { 1570 symbolS *add = fix_ptr->fx_addsy; 1571 symbolS *sub = fix_ptr->fx_subsy; 1572 1573 if (S_GET_SEGMENT (add) != S_GET_SEGMENT (sub)) 1574 as_bad (_("Can't subtract symbols in different sections %s %s"), 1575 S_GET_NAME (add), S_GET_NAME (sub)); 1576 else 1577 { 1578 int diff = S_GET_VALUE (add) - S_GET_VALUE (sub); 1579 1580 fix_ptr->fx_addsy = 0; 1581 fix_ptr->fx_subsy = 0; 1582 fix_ptr->fx_offset += diff; 1583 } 1584 } 1585 symbol_ptr = fix_ptr->fx_addsy; 1586 1587 /* If this relocation is attached to a symbol then it's ok 1588 to output it. */ 1589 if (fix_ptr->fx_r_type == 0) 1590 { 1591 /* cons likes to create reloc32's whatever the size of the reloc. */ 1592 switch (fix_ptr->fx_size) 1593 { 1594 case 2: 1595 intr->r_type = R_IMM16; 1596 break; 1597 case 1: 1598 intr->r_type = R_IMM8; 1599 break; 1600 case 4: 1601 intr->r_type = R_IMM32; 1602 break; 1603 default: 1604 abort (); 1605 } 1606 } 1607 else 1608 intr->r_type = fix_ptr->fx_r_type; 1609 1610 intr->r_vaddr = fix_ptr->fx_frag->fr_address + fix_ptr->fx_where + base; 1611 intr->r_offset = fix_ptr->fx_offset; 1612 1613 if (symbol_ptr) 1614 intr->r_symndx = symbol_ptr->sy_number; 1615 else 1616 intr->r_symndx = -1; 1617 } 1618