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