gas/config/tc-z8k.c

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