gas/config/tc-z8k.c

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