gas/config/tc-z8k.c

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