gas/config/tc-sh.c

   1 /* tc-sh.c -- Assemble code for the Hitachi Super-H
   2
   3    Copyright (C) 1993, 1994, 1995 Free Software Foundation.
   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
  19    the Free Software Foundation, 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 /*
  23    Written By Steve Chamberlain
  24    sac@cygnus.com
  25  */
  26
  27 #include <stdio.h>
  28 #include "as.h"
  29 #include "bfd.h"
  30 #include "subsegs.h"
  31 #define DEFINE_TABLE
  32 #include "opcodes/sh-opc.h"
  33 #include <ctype.h>
  34 const char comment_chars[] = "!";
  35 const char line_separator_chars[] = ";";
  36 const char line_comment_chars[] = "!#";
  37
  38 static void s_uses PARAMS ((int));
  39
  40 /* This table describes all the machine specific pseudo-ops the assembler
  41    has to support.  The fields are:
  42    pseudo-op name without dot
  43    function to call to execute this pseudo-op
  44    Integer arg to pass to the function
  45  */
  46
  47 void cons ();
  48 void s_align_bytes ();
  49
  50 int shl = 0;
  51
  52 static void
  53 little (ignore)
  54      int ignore;
  55 {
  56   shl = 1;
  57   target_big_endian = 0;
  58 }
  59
  60 const pseudo_typeS md_pseudo_table[] =
  61 {
  62   {"int", cons, 4},
  63   {"word", cons, 2},
  64   {"form", listing_psize, 0},
  65   {"little", little, 0},
  66   {"heading", listing_title, 0},
  67   {"import", s_ignore, 0},
  68   {"page", listing_eject, 0},
  69   {"program", s_ignore, 0},
  70   {"uses", s_uses, 0},
  71   {0, 0, 0}
  72 };
  73
  74 /*int md_reloc_size; */
  75
  76 int sh_relax;           /* set if -relax seen */
  77
  78 const char EXP_CHARS[] = "eE";
  79
  80 /* Chars that mean this number is a floating point constant */
  81 /* As in 0f12.456 */
  82 /* or    0d1.2345e12 */
  83 const char FLT_CHARS[] = "rRsSfFdDxXpP";
  84
  85 #define C(a,b) ENCODE_RELAX(a,b)
  86
  87 #define JREG 14                 /* Register used as a temp when relaxing */
  88 #define ENCODE_RELAX(what,length) (((what) << 4) + (length))
  89 #define GET_WHAT(x) ((x>>4))
  90
  91 /* These are the two types of relaxable instrction */
  92 #define COND_JUMP 1
  93 #define UNCOND_JUMP  2
  94
  95 #define UNDEF_DISP 0
  96 #define COND8  1
  97 #define COND12 2
  98 #define COND32 3
  99 #define UNCOND12 1
 100 #define UNCOND32 2
 101 #define UNDEF_WORD_DISP 4
 102 #define END 5
 103
 104 #define UNCOND12 1
 105 #define UNCOND32 2
 106
 107 /* Branch displacements are from the address of the branch plus
 108    four, thus all minimum and maximum values have 4 added to them.  */
 109 #define COND8_F 258
 110 #define COND8_M -252
 111 #define COND8_LENGTH 2
 112
 113 /* There is one extra instruction before the branch, so we must add
 114    two more bytes to account for it.  */
 115 #define COND12_F 4100
 116 #define COND12_M -4090
 117 #define COND12_LENGTH 6
 118
 119 /* ??? The minimum and maximum values are wrong, but this does not matter
 120    since this relocation type is not supported yet.  */
 121 #define COND32_F (1<<30)
 122 #define COND32_M -(1<<30)
 123 #define COND32_LENGTH 14
 124
 125 #define UNCOND12_F 4098
 126 #define UNCOND12_M -4092
 127 #define UNCOND12_LENGTH 2
 128
 129 /* ??? The minimum and maximum values are wrong, but this does not matter
 130    since this relocation type is not supported yet.  */
 131 #define UNCOND32_F (1<<30)
 132 #define UNCOND32_M -(1<<30)
 133 #define UNCOND32_LENGTH 14
 134
 135 const relax_typeS md_relax_table[C (END, 0)] = {
 136   { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 },
 137   { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 },
 138
 139   { 0 },
 140   /* C (COND_JUMP, COND8) */
 141   { COND8_F, COND8_M, COND8_LENGTH, C (COND_JUMP, COND12) },
 142   /* C (COND_JUMP, COND12) */
 143   { COND12_F, COND12_M, COND12_LENGTH, C (COND_JUMP, COND32), },
 144   /* C (COND_JUMP, COND32) */
 145   { COND32_F, COND32_M, COND32_LENGTH, 0, },
 146   { 0 }, { 0 }, { 0 }, { 0 },
 147   { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 },
 148
 149   { 0 },
 150   /* C (UNCOND_JUMP, UNCOND12) */
 151   { UNCOND12_F, UNCOND12_M, UNCOND12_LENGTH, C (UNCOND_JUMP, UNCOND32), },
 152   /* C (UNCOND_JUMP, UNCOND32) */
 153   { UNCOND32_F, UNCOND32_M, UNCOND32_LENGTH, 0, },
 154   { 0 }, { 0 }, { 0 }, { 0 }, { 0 },
 155   { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 },
 156 };
 157
 158 static struct hash_control *opcode_hash_control;        /* Opcode mnemonics */
 159
 160 /*
 161    This function is called once, at assembler startup time.  This should
 162    set up all the tables, etc that the MD part of the assembler needs
 163  */
 164
 165 void
 166 md_begin ()
 167 {
 168   sh_opcode_info *opcode;
 169   char *prev_name = "";
 170
 171   if (! shl)
 172     target_big_endian = 1;
 173
 174   opcode_hash_control = hash_new ();
 175
 176   /* Insert unique names into hash table */
 177   for (opcode = sh_table; opcode->name; opcode++)
 178     {
 179       if (strcmp (prev_name, opcode->name))
 180         {
 181           prev_name = opcode->name;
 182           hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
 183         }
 184       else
 185         {
 186           /* Make all the opcodes with the same name point to the same
 187              string */
 188           opcode->name = prev_name;
 189         }
 190     }
 191 }
 192
 193 static int reg_m;
 194 static int reg_n;
 195 static int reg_b;
 196
 197 static expressionS immediate;   /* absolute expression */
 198
 199 typedef struct
 200   {
 201     sh_arg_type type;
 202     int reg;
 203   }
 204
 205 sh_operand_info;
 206
 207 /* try and parse a reg name, returns number of chars consumed */
 208 static int
 209 parse_reg (src, mode, reg)
 210      char *src;
 211      int *mode;
 212      int *reg;
 213 {
 214   /* We use !isalnum for the next character after the register name, to
 215      make sure that we won't accidentally recognize a symbol name such as
 216      'sram' as being a reference to the register 'sr'.  */
 217
 218   if (src[0] == 'r')
 219     {
 220       if (src[1] >= '0' && src[1] <= '7' && strncmp(&src[2], "_bank", 5) == 0
 221           && ! isalnum (src[7]))
 222         {
 223           *mode = A_REG_B;
 224           *reg  = (src[1] - '0');
 225           return 7;
 226         }
 227     }
 228
 229   if (src[0] == 'r')
 230     {
 231       if (src[1] == '1')
 232         {
 233           if (src[2] >= '0' && src[2] <= '5' && ! isalnum (src[3]))
 234             {
 235               *mode = A_REG_N;
 236               *reg = 10 + src[2] - '0';
 237               return 3;
 238             }
 239         }
 240       if (src[1] >= '0' && src[1] <= '9' && ! isalnum (src[2]))
 241         {
 242           *mode = A_REG_N;
 243           *reg = (src[1] - '0');
 244           return 2;
 245         }
 246     }
 247
 248   if (src[0] == 's' && src[1] == 's' && src[2] == 'r' && ! isalnum (src[3]))
 249     {
 250       *mode = A_SSR;
 251       return 3;
 252     }
 253
 254   if (src[0] == 's' && src[1] == 'p' && src[2] == 'c' && ! isalnum (src[3]))
 255     {
 256       *mode = A_SPC;
 257       return 3;
 258     }
 259
 260   if (src[0] == 's' && src[1] == 'r' && ! isalnum (src[2]))
 261     {
 262       *mode = A_SR;
 263       return 2;
 264     }
 265
 266   if (src[0] == 's' && src[1] == 'p' && ! isalnum (src[2]))
 267     {
 268       *mode = A_REG_N;
 269       *reg = 15;
 270       return 2;
 271     }
 272
 273   if (src[0] == 'p' && src[1] == 'r' && ! isalnum (src[2]))
 274     {
 275       *mode = A_PR;
 276       return 2;
 277     }
 278   if (src[0] == 'p' && src[1] == 'c' && ! isalnum (src[2]))
 279     {
 280       *mode = A_DISP_PC;
 281       return 2;
 282     }
 283   if (src[0] == 'g' && src[1] == 'b' && src[2] == 'r' && ! isalnum (src[3]))
 284     {
 285       *mode = A_GBR;
 286       return 3;
 287     }
 288   if (src[0] == 'v' && src[1] == 'b' && src[2] == 'r' && ! isalnum (src[3]))
 289     {
 290       *mode = A_VBR;
 291       return 3;
 292     }
 293
 294   if (src[0] == 'm' && src[1] == 'a' && src[2] == 'c' && ! isalnum (src[4]))
 295     {
 296       if (src[3] == 'l')
 297         {
 298           *mode = A_MACL;
 299           return 4;
 300         }
 301       if (src[3] == 'h')
 302         {
 303           *mode = A_MACH;
 304           return 4;
 305         }
 306     }
 307   if (src[0] == 'f' && src[1] == 'r')
 308     {
 309       if (src[2] == '1')
 310         {
 311           if (src[3] >= '0' && src[3] <= '5' && ! isalnum (src[4]))
 312             {
 313               *mode = F_REG_N;
 314               *reg = 10 + src[3] - '0';
 315               return 4;
 316             }
 317         }
 318       if (src[2] >= '0' && src[2] <= '9' && ! isalnum (src[3]))
 319         {
 320           *mode = F_REG_N;
 321           *reg = (src[2] - '0');
 322           return 3;
 323         }
 324     }
 325   if (src[0] == 'f' && src[1] == 'p' && src[2] == 'u' && src[3] == 'l'
 326       && ! isalnum (src[4]))
 327     {
 328       *mode = FPUL_N;
 329       return 4;
 330     }
 331
 332   if (src[0] == 'f' && src[1] == 'p' && src[2] == 's' && src[3] == 'c'
 333       && src[4] == 'r' && ! isalnum (src[5]))
 334     {
 335       *mode = FPSCR_N;
 336       return 5;
 337     }
 338
 339   return 0;
 340 }
 341
 342 static symbolS *dot()
 343 {
 344   const char *fake;
 345
 346   /* JF: '.' is pseudo symbol with value of current location
 347      in current segment.  */
 348   fake = FAKE_LABEL_NAME;
 349   return  symbol_new (fake,
 350                       now_seg,
 351                       (valueT) frag_now_fix (),
 352                       frag_now);
 353
 354 }
 355
 356
 357 static
 358 char *
 359 parse_exp (s)
 360      char *s;
 361 {
 362   char *save;
 363   char *new;
 364
 365   save = input_line_pointer;
 366   input_line_pointer = s;
 367   expression (&immediate);
 368   if (immediate.X_op == O_absent)
 369     as_bad ("missing operand");
 370   new = input_line_pointer;
 371   input_line_pointer = save;
 372   return new;
 373 }
 374
 375
 376 /* The many forms of operand:
 377
 378    Rn                   Register direct
 379    @Rn                  Register indirect
 380    @Rn+                 Autoincrement
 381    @-Rn                 Autodecrement
 382    @(disp:4,Rn)
 383    @(disp:8,GBR)
 384    @(disp:8,PC)
 385
 386    @(R0,Rn)
 387    @(R0,GBR)
 388
 389    disp:8
 390    disp:12
 391    #imm8
 392    pr, gbr, vbr, macl, mach
 393
 394  */
 395
 396 static
 397 char *
 398 parse_at (src, op)
 399      char *src;
 400      sh_operand_info *op;
 401 {
 402   int len;
 403   int mode;
 404   src++;
 405   if (src[0] == '-')
 406     {
 407       /* Must be predecrement */
 408       src++;
 409
 410       len = parse_reg (src, &mode, &(op->reg));
 411       if (mode != A_REG_N)
 412         as_bad ("illegal register after @-");
 413
 414       op->type = A_DEC_N;
 415       src += len;
 416     }
 417   else if (src[0] == '(')
 418     {
 419       /* Could be @(disp, rn), @(disp, gbr), @(disp, pc),  @(r0, gbr) or
 420          @(r0, rn) */
 421       src++;
 422       len = parse_reg (src, &mode, &(op->reg));
 423       if (len && mode == A_REG_N)
 424         {
 425           src += len;
 426           if (op->reg != 0)
 427             {
 428               as_bad ("must be @(r0,...)");
 429             }
 430           if (src[0] == ',')
 431             src++;
 432           /* Now can be rn or gbr */
 433           len = parse_reg (src, &mode, &(op->reg));
 434           if (mode == A_GBR)
 435             {
 436               op->type = A_R0_GBR;
 437             }
 438           else if (mode == A_REG_N)
 439             {
 440               op->type = A_IND_R0_REG_N;
 441             }
 442           else
 443             {
 444               as_bad ("syntax error in @(r0,...)");
 445             }
 446         }
 447       else
 448         {
 449           /* Must be an @(disp,.. thing) */
 450           src = parse_exp (src);
 451           if (src[0] == ',')
 452             src++;
 453           /* Now can be rn, gbr or pc */
 454           len = parse_reg (src, &mode, &op->reg);
 455           if (len)
 456             {
 457               if (mode == A_REG_N)
 458                 {
 459                   op->type = A_DISP_REG_N;
 460                 }
 461               else if (mode == A_GBR)
 462                 {
 463                   op->type = A_DISP_GBR;
 464                 }
 465               else if (mode == A_DISP_PC)
 466                 {
 467                   /* Turn a plain @(4,pc) into @(.+4,pc) */
 468                   if (immediate.X_op == O_constant) {
 469                     immediate.X_add_symbol = dot();
 470                     immediate.X_op = O_symbol;
 471                   }
 472                   op->type = A_DISP_PC;
 473                 }
 474               else
 475                 {
 476                   as_bad ("syntax error in @(disp,[Rn, gbr, pc])");
 477                 }
 478             }
 479           else
 480             {
 481               as_bad ("syntax error in @(disp,[Rn, gbr, pc])");
 482             }
 483         }
 484       src += len;
 485       if (src[0] != ')')
 486         as_bad ("expecting )");
 487       else
 488         src++;
 489     }
 490   else
 491     {
 492       src += parse_reg (src, &mode, &(op->reg));
 493       if (mode != A_REG_N)
 494         {
 495           as_bad ("illegal register after @");
 496         }
 497       if (src[0] == '+')
 498         {
 499           op->type = A_INC_N;
 500           src++;
 501         }
 502       else
 503         {
 504           op->type = A_IND_N;
 505         }
 506     }
 507   return src;
 508 }
 509
 510 static void
 511 get_operand (ptr, op)
 512      char **ptr;
 513      sh_operand_info *op;
 514 {
 515   char *src = *ptr;
 516   int mode = -1;
 517   unsigned int len;
 518
 519   if (src[0] == '#')
 520     {
 521       src++;
 522       *ptr = parse_exp (src);
 523       op->type = A_IMM;
 524       return;
 525     }
 526
 527   else if (src[0] == '@')
 528     {
 529       *ptr = parse_at (src, op);
 530       return;
 531     }
 532   len = parse_reg (src, &mode, &(op->reg));
 533   if (len)
 534     {
 535       *ptr = src + len;
 536       op->type = mode;
 537       return;
 538     }
 539   else
 540     {
 541       /* Not a reg, the only thing left is a displacement */
 542       *ptr = parse_exp (src);
 543       op->type = A_DISP_PC;
 544       return;
 545     }
 546 }
 547
 548 static
 549 char *
 550 get_operands (info, args, operand)
 551      sh_opcode_info *info;
 552      char *args;
 553      sh_operand_info *operand;
 554
 555 {
 556   char *ptr = args;
 557   if (info->arg[0])
 558     {
 559       ptr++;
 560
 561       get_operand (&ptr, operand + 0);
 562       if (info->arg[1])
 563         {
 564           if (*ptr == ',')
 565             {
 566               ptr++;
 567             }
 568           get_operand (&ptr, operand + 1);
 569           if (info->arg[2])
 570             {
 571               if (*ptr == ',')
 572                 {
 573                   ptr++;
 574                 }
 575               get_operand (&ptr, operand + 2);
 576             }
 577           else
 578             {
 579               operand[2].type = 0;
 580             }
 581         }
 582       else
 583         {
 584           operand[1].type = 0;
 585           operand[2].type = 0;
 586         }
 587     }
 588   else
 589     {
 590       operand[0].type = 0;
 591       operand[1].type = 0;
 592       operand[2].type = 0;
 593     }
 594   return ptr;
 595 }
 596
 597 /* Passed a pointer to a list of opcodes which use different
 598    addressing modes, return the opcode which matches the opcodes
 599    provided
 600  */
 601
 602 static
 603 sh_opcode_info *
 604 get_specific (opcode, operands)
 605      sh_opcode_info *opcode;
 606      sh_operand_info *operands;
 607 {
 608   sh_opcode_info *this_try = opcode;
 609   char *name = opcode->name;
 610   int n = 0;
 611   while (opcode->name)
 612     {
 613       this_try = opcode++;
 614       if (this_try->name != name)
 615         {
 616           /* We've looked so far down the table that we've run out of
 617              opcodes with the same name */
 618           return 0;
 619         }
 620       /* look at both operands needed by the opcodes and provided by
 621          the user - since an arg test will often fail on the same arg
 622          again and again, we'll try and test the last failing arg the
 623          first on each opcode try */
 624
 625       for (n = 0; this_try->arg[n]; n++)
 626         {
 627           sh_operand_info *user = operands + n;
 628           sh_arg_type arg = this_try->arg[n];
 629           switch (arg)
 630             {
 631             case A_IMM:
 632             case A_BDISP12:
 633             case A_BDISP8:
 634             case A_DISP_GBR:
 635             case A_DISP_PC:
 636             case A_MACH:
 637             case A_PR:
 638             case A_MACL:
 639               if (user->type != arg)
 640                 goto fail;
 641               break;
 642             case A_R0:
 643               /* opcode needs r0 */
 644               if (user->type != A_REG_N || user->reg != 0)
 645                 goto fail;
 646               break;
 647             case A_R0_GBR:
 648               if (user->type != A_R0_GBR || user->reg != 0)
 649                 goto fail;
 650               break;
 651             case F_FR0:
 652               if (user->type != F_REG_N || user->reg != 0)
 653                 goto fail;
 654               break;
 655
 656             case A_REG_N:
 657             case A_INC_N:
 658             case A_DEC_N:
 659             case A_IND_N:
 660             case A_IND_R0_REG_N:
 661             case A_DISP_REG_N:
 662             case F_REG_N:
 663             case FPUL_N:
 664             case FPSCR_N:
 665               /* Opcode needs rn */
 666               if (user->type != arg)
 667                 goto fail;
 668               reg_n = user->reg;
 669               break;
 670             case A_GBR:
 671             case A_SR:
 672             case A_VBR:
 673             case A_SSR:
 674             case A_SPC:
 675               if (user->type != arg)
 676                 goto fail;
 677               break;
 678
 679             case A_REG_B:
 680               if (user->type != arg)
 681                 goto fail;
 682               reg_b = user->reg;
 683               break;
 684
 685             case A_REG_M:
 686             case A_INC_M:
 687             case A_DEC_M:
 688             case A_IND_M:
 689             case A_IND_R0_REG_M:
 690             case A_DISP_REG_M:
 691               /* Opcode needs rn */
 692               if (user->type != arg - A_REG_M + A_REG_N)
 693                 goto fail;
 694               reg_m = user->reg;
 695               break;
 696
 697             case F_REG_M:
 698             case FPUL_M:
 699             case FPSCR_M:
 700               /* Opcode needs rn */
 701               if (user->type != arg - F_REG_M + F_REG_N)
 702                 goto fail;
 703               reg_m = user->reg;
 704               break;
 705
 706             default:
 707               printf ("unhandled %d\n", arg);
 708               goto fail;
 709             }
 710         }
 711       return this_try;
 712     fail:;
 713     }
 714
 715   return 0;
 716 }
 717
 718 int
 719 check (operand, low, high)
 720      expressionS *operand;
 721      int low;
 722      int high;
 723 {
 724   if (operand->X_op != O_constant
 725       || operand->X_add_number < low
 726       || operand->X_add_number > high)
 727     {
 728       as_bad ("operand must be absolute in range %d..%d", low, high);
 729     }
 730   return operand->X_add_number;
 731 }
 732
 733
 734 static void
 735 insert (where, how, pcrel)
 736      char *where;
 737      int how;
 738      int pcrel;
 739 {
 740   fix_new_exp (frag_now,
 741                where - frag_now->fr_literal,
 742                2,
 743                &immediate,
 744                pcrel,
 745                how);
 746 }
 747
 748 static void
 749 build_relax (opcode)
 750      sh_opcode_info *opcode;
 751 {
 752   int high_byte = target_big_endian ? 0 : 1;
 753   char *p;
 754
 755   if (opcode->arg[0] == A_BDISP8)
 756     {
 757       p = frag_var (rs_machine_dependent,
 758                     md_relax_table[C (COND_JUMP, COND32)].rlx_length,
 759                     md_relax_table[C (COND_JUMP, COND8)].rlx_length,
 760                     C (COND_JUMP, 0),
 761                     immediate.X_add_symbol,
 762                     immediate.X_add_number,
 763                     0);
 764       p[high_byte] = (opcode->nibbles[0] << 4) | (opcode->nibbles[1]);
 765     }
 766   else if (opcode->arg[0] == A_BDISP12)
 767     {
 768       p = frag_var (rs_machine_dependent,
 769                     md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length,
 770                     md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length,
 771                     C (UNCOND_JUMP, 0),
 772                     immediate.X_add_symbol,
 773                     immediate.X_add_number,
 774                     0);
 775       p[high_byte] = (opcode->nibbles[0] << 4);
 776     }
 777
 778 }
 779
 780 /* Now we know what sort of opcodes it is, lets build the bytes -
 781  */
 782 static void
 783 build_Mytes (opcode, operand)
 784      sh_opcode_info *opcode;
 785      sh_operand_info *operand;
 786
 787 {
 788   int index;
 789   char nbuf[4];
 790   char *output = frag_more (2);
 791   int low_byte = target_big_endian ? 1 : 0;
 792   nbuf[0] = 0;
 793   nbuf[1] = 0;
 794   nbuf[2] = 0;
 795   nbuf[3] = 0;
 796
 797   for (index = 0; index < 4; index++)
 798     {
 799       sh_nibble_type i = opcode->nibbles[index];
 800       if (i < 16)
 801         {
 802           nbuf[index] = i;
 803         }
 804       else
 805         {
 806           switch (i)
 807             {
 808             case REG_N:
 809               nbuf[index] = reg_n;
 810               break;
 811             case REG_M:
 812               nbuf[index] = reg_m;
 813               break;
 814             case REG_B:
 815               nbuf[index] = reg_b | 0x08;
 816               break;
 817             case DISP_4:
 818               insert (output + low_byte, R_SH_IMM4, 0);
 819               break;
 820             case IMM_4BY4:
 821               insert (output + low_byte, R_SH_IMM4BY4, 0);
 822               break;
 823             case IMM_4BY2:
 824               insert (output + low_byte, R_SH_IMM4BY2, 0);
 825               break;
 826             case IMM_4:
 827               insert (output + low_byte, R_SH_IMM4, 0);
 828               break;
 829             case IMM_8BY4:
 830               insert (output + low_byte, R_SH_IMM8BY4, 0);
 831               break;
 832             case IMM_8BY2:
 833               insert (output + low_byte, R_SH_IMM8BY2, 0);
 834               break;
 835             case IMM_8:
 836               insert (output + low_byte, R_SH_IMM8, 0);
 837               break;
 838             case PCRELIMM_8BY4:
 839               insert (output, R_SH_PCRELIMM8BY4, 1);
 840               break;
 841             case PCRELIMM_8BY2:
 842               insert (output, R_SH_PCRELIMM8BY2, 1);
 843               break;
 844             default:
 845               printf ("failed for %d\n", i);
 846             }
 847         }
 848     }
 849   if (! target_big_endian) {
 850     output[1] = (nbuf[0] << 4) | (nbuf[1]);
 851     output[0] = (nbuf[2] << 4) | (nbuf[3]);
 852   }
 853   else {
 854     output[0] = (nbuf[0] << 4) | (nbuf[1]);
 855     output[1] = (nbuf[2] << 4) | (nbuf[3]);
 856   }
 857 }
 858
 859 /* This is the guts of the machine-dependent assembler.  STR points to a
 860    machine dependent instruction.  This function is supposed to emit
 861    the frags/bytes it assembles to.
 862  */
 863
 864 void
 865 md_assemble (str)
 866      char *str;
 867 {
 868   unsigned char *op_start;
 869   unsigned char *op_end;
 870   sh_operand_info operand[3];
 871   sh_opcode_info *opcode;
 872   char name[20];
 873   int nlen = 0;
 874   /* Drop leading whitespace */
 875   while (*str == ' ')
 876     str++;
 877
 878   /* find the op code end */
 879   for (op_start = op_end = (unsigned char *) (str);
 880        *op_end
 881        && nlen < 20
 882        && !is_end_of_line[*op_end] && *op_end != ' ';
 883        op_end++)
 884     {
 885       name[nlen] = op_start[nlen];
 886       nlen++;
 887     }
 888   name[nlen] = 0;
 889
 890   if (nlen == 0)
 891     {
 892       as_bad ("can't find opcode ");
 893     }
 894
 895   opcode = (sh_opcode_info *) hash_find (opcode_hash_control, name);
 896
 897   if (opcode == NULL)
 898     {
 899       as_bad ("unknown opcode");
 900       return;
 901     }
 902
 903   if (opcode->arg[0] == A_BDISP12
 904       || opcode->arg[0] == A_BDISP8)
 905     {
 906       parse_exp (op_end + 1);
 907       build_relax (opcode);
 908     }
 909   else
 910     {
 911       if (opcode->arg[0] != A_END)
 912         {
 913           get_operands (opcode, op_end, operand);
 914         }
 915       opcode = get_specific (opcode, operand);
 916
 917       if (opcode == 0)
 918         {
 919           /* Couldn't find an opcode which matched the operands */
 920           char *where = frag_more (2);
 921
 922           where[0] = 0x0;
 923           where[1] = 0x0;
 924           as_bad ("invalid operands for opcode");
 925           return;
 926         }
 927
 928       build_Mytes (opcode, operand);
 929     }
 930
 931 }
 932
 933 void
 934 DEFUN (tc_crawl_symbol_chain, (headers),
 935        object_headers * headers)
 936 {
 937   printf ("call to tc_crawl_symbol_chain \n");
 938 }
 939
 940 symbolS *
 941 DEFUN (md_undefined_symbol, (name),
 942        char *name)
 943 {
 944   return 0;
 945 }
 946
 947 void
 948 DEFUN (tc_headers_hook, (headers),
 949        object_headers * headers)
 950 {
 951   printf ("call to tc_headers_hook \n");
 952 }
 953
 954 /* Various routines to kill one day */
 955 /* Equal to MAX_PRECISION in atof-ieee.c */
 956 #define MAX_LITTLENUMS 6
 957
 958 /* Turn a string in input_line_pointer into a floating point constant of type
 959    type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
 960    emitted is stored in *sizeP .  An error message is returned, or NULL on OK.
 961  */
 962 char *
 963 md_atof (type, litP, sizeP)
 964      int type;
 965      char *litP;
 966      int *sizeP;
 967 {
 968   int prec;
 969   LITTLENUM_TYPE words[4];
 970   char *t;
 971   int i;
 972
 973   switch (type)
 974     {
 975     case 'f':
 976       prec = 2;
 977       break;
 978
 979     case 'd':
 980       prec = 4;
 981       break;
 982
 983     default:
 984       *sizeP = 0;
 985       return "bad call to md_atof";
 986     }
 987
 988   t = atof_ieee (input_line_pointer, type, words);
 989   if (t)
 990     input_line_pointer = t;
 991
 992   *sizeP = prec * 2;
 993
 994   if (! target_big_endian)
 995     {
 996       for (i = prec - 1; i >= 0; i--)
 997         {
 998           md_number_to_chars (litP, (valueT) words[i], 2);
 999           litP += 2;
1000         }
1001     }
1002   else
1003     {
1004       for (i = 0; i < prec; i++)
1005         {
1006           md_number_to_chars (litP, (valueT) words[i], 2);
1007           litP += 2;
1008         }
1009     }
1010
1011   return NULL;
1012 }
1013
1014 /* Handle the .uses pseudo-op.  This pseudo-op is used just before a
1015    call instruction.  It refers to a label of the instruction which
1016    loads the register which the call uses.  We use it to generate a
1017    special reloc for the linker.  */
1018
1019 static void
1020 s_uses (ignore)
1021      int ignore;
1022 {
1023   expressionS ex;
1024
1025   if (! sh_relax)
1026     as_warn (".uses pseudo-op seen when not relaxing");
1027
1028   expression (&ex);
1029
1030   if (ex.X_op != O_symbol || ex.X_add_number != 0)
1031     {
1032       as_bad ("bad .uses format");
1033       ignore_rest_of_line ();
1034       return;
1035     }
1036
1037   fix_new_exp (frag_now, frag_now_fix (), 2, &ex, 1, R_SH_USES);
1038
1039   demand_empty_rest_of_line ();
1040 }
1041 \f
1042 CONST char *md_shortopts = "";
1043 struct option md_longopts[] = {
1044
1045 #define OPTION_RELAX  (OPTION_MD_BASE)
1046 #define OPTION_LITTLE (OPTION_MD_BASE+1)
1047
1048   {"relax", no_argument, NULL, OPTION_RELAX},
1049   {"little", no_argument, NULL, OPTION_LITTLE},
1050   {NULL, no_argument, NULL, 0}
1051 };
1052 size_t md_longopts_size = sizeof(md_longopts);
1053
1054 int
1055 md_parse_option (c, arg)
1056      int c;
1057      char *arg;
1058 {
1059   switch (c)
1060     {
1061     case OPTION_RELAX:
1062       sh_relax = 1;
1063       break;
1064     case OPTION_LITTLE:
1065       shl = 1;
1066       target_big_endian = 0;
1067       break;
1068
1069     default:
1070       return 0;
1071     }
1072
1073   return 1;
1074 }
1075
1076 void
1077 md_show_usage (stream)
1078      FILE *stream;
1079 {
1080   fprintf(stream, "\
1081 SH options:\n\
1082 -little                 generate little endian code\n\
1083 -relax                  alter jump instructions for long displacements\n");
1084 }
1085 \f
1086 int md_short_jump_size;
1087
1088 void
1089 tc_Nout_fix_to_chars ()
1090 {
1091   printf ("call to tc_Nout_fix_to_chars \n");
1092   abort ();
1093 }
1094
1095 void
1096 md_create_short_jump (ptr, from_Nddr, to_Nddr, frag, to_symbol)
1097      char *ptr;
1098      addressT from_Nddr;
1099      addressT to_Nddr;
1100      fragS *frag;
1101      symbolS *to_symbol;
1102 {
1103   as_fatal ("failed sanity check.");
1104 }
1105
1106 void
1107 md_create_long_jump (ptr, from_Nddr, to_Nddr, frag, to_symbol)
1108      char *ptr;
1109      addressT from_Nddr, to_Nddr;
1110      fragS *frag;
1111      symbolS *to_symbol;
1112 {
1113   as_fatal ("failed sanity check.");
1114 }
1115
1116 /* This is function is called after the symbol table has been
1117    completed, but before md_convert_frag has been called.  If we have
1118    seen any .uses pseudo-ops, they point to an instruction which loads
1119    a register with the address of a function.  We look through the
1120    fixups to find where the function address is being loaded from.  We
1121    then generate a COUNT reloc giving the number of times that
1122    function address is referred to.  The linker uses this information
1123    when doing relaxing, to decide when it can eliminate the stored
1124    function address entirely.  */
1125
1126 void
1127 sh_coff_frob_file ()
1128 {
1129   int iseg;
1130
1131   if (! sh_relax)
1132     return;
1133
1134   for (iseg = SEG_E0; iseg < SEG_UNKNOWN; iseg++)
1135     {
1136       fixS *fix;
1137
1138       for (fix = segment_info[iseg].fix_root; fix != NULL; fix = fix->fx_next)
1139         {
1140           symbolS *sym;
1141           bfd_vma val;
1142           bfd_vma paddr;
1143           fixS *fscan;
1144           int iscan;
1145           int count;
1146
1147           if (fix->fx_r_type != R_SH_USES)
1148             continue;
1149
1150           /* The R_SH_USES reloc should refer to a defined local
1151              symbol in the same section.  */
1152           sym = fix->fx_addsy;
1153           if (sym == NULL
1154               || fix->fx_subsy != NULL
1155               || fix->fx_addnumber != 0
1156               || S_GET_SEGMENT (sym) != iseg
1157               || S_GET_STORAGE_CLASS (sym) == C_EXT)
1158             {
1159               as_warn_where (fix->fx_file, fix->fx_line,
1160                              ".uses does not refer to a local symbol in the same section");
1161               continue;
1162             }
1163
1164           /* Look through the fixups again, this time looking for one
1165              at the same location as sym.  */
1166           val = S_GET_VALUE (sym);
1167           paddr = segment_info[iseg].scnhdr.s_paddr;
1168           for (fscan = segment_info[iseg].fix_root;
1169                fscan != NULL;
1170                fscan = fscan->fx_next)
1171             if (val == paddr + fscan->fx_frag->fr_address + fscan->fx_where)
1172               break;
1173           if (fscan == NULL)
1174             {
1175               as_warn_where (fix->fx_file, fix->fx_line,
1176                              "can't find fixup pointed to by .uses");
1177               continue;
1178             }
1179
1180           if (fscan->fx_tcbit)
1181             {
1182               /* We've already done this one.  */
1183               continue;
1184             }
1185
1186           /* fscan should also be a fixup to a local symbol in the same
1187              section.  */
1188           sym = fscan->fx_addsy;
1189           if (sym == NULL
1190               || fscan->fx_subsy != NULL
1191               || fscan->fx_addnumber != 0
1192               || S_GET_SEGMENT (sym) != iseg
1193               || S_GET_STORAGE_CLASS (sym) == C_EXT)
1194             {
1195               as_warn_where (fix->fx_file, fix->fx_line,
1196                              ".uses target does not refer to a local symbol in the same section");
1197               continue;
1198             }
1199
1200           /* Now we look through all the fixups of all the sections,
1201              counting the number of times we find a reference to sym.  */
1202           count = 0;
1203           for (iscan = SEG_E0; iscan < SEG_UNKNOWN; iscan++)
1204             {
1205               paddr = segment_info[iscan].scnhdr.s_paddr;
1206               for (fscan = segment_info[iscan].fix_root;
1207                    fscan != NULL;
1208                    fscan = fscan->fx_next)
1209                 {
1210                   if (fscan->fx_addsy == sym)
1211                     {
1212                       ++count;
1213                       fscan->fx_tcbit = 1;
1214                     }
1215                 }
1216             }
1217
1218           if (count < 1)
1219             abort ();
1220
1221           /* Generate a R_SH_COUNT fixup at the location of sym.  We
1222              have already adjusted the value of sym to include the
1223              fragment address, so we undo that adjustment here.  */
1224           subseg_change (iseg, 0);
1225           fix_new (sym->sy_frag, S_GET_VALUE (sym) - sym->sy_frag->fr_address,
1226                    4, &abs_symbol, count, 0, R_SH_COUNT);
1227         }
1228     }
1229 }
1230
1231 /* Called after relaxing.  Set the correct sizes of the fragments, and
1232    create relocs so that md_apply_fix will fill in the correct values.  */
1233
1234 void
1235 md_convert_frag (headers, seg, fragP)
1236      object_headers *headers;
1237      segT seg;
1238      fragS *fragP;
1239 {
1240   int donerelax = 0;
1241
1242   switch (fragP->fr_subtype)
1243     {
1244     case C (COND_JUMP, COND8):
1245       subseg_change (seg, 0);
1246       fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
1247                1, R_SH_PCDISP8BY2);
1248       fragP->fr_fix += 2;
1249       fragP->fr_var = 0;
1250       break;
1251
1252     case C (UNCOND_JUMP, UNCOND12):
1253       subseg_change (seg, 0);
1254       fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
1255                1, R_SH_PCDISP);
1256       fragP->fr_fix += 2;
1257       fragP->fr_var = 0;
1258       break;
1259
1260     case C (UNCOND_JUMP, UNCOND32):
1261     case C (UNCOND_JUMP, UNDEF_WORD_DISP):
1262       if (fragP->fr_symbol == NULL)
1263         as_bad ("at 0x%lx, displacement overflows 12-bit field",
1264                 (unsigned long) fragP->fr_address);
1265       else
1266         as_bad ("at 0x%lx, displacement to %sdefined symbol %s overflows 12-bit field",
1267                 (unsigned long) fragP->fr_address,
1268                 S_IS_DEFINED (fragP->fr_symbol) ? "" : "un",
1269                 S_GET_NAME (fragP->fr_symbol));
1270
1271 #if 0                           /* This code works, but generates poor code and the compiler
1272                                    should never produce a sequence that requires it to be used.  */
1273
1274       /* A jump wont fit in 12 bits, make code which looks like
1275          bra foo
1276          mov.w @(0, PC), r14
1277          .long disp
1278          foo: bra @r14
1279          */
1280       int t = buffer[0] & 0x10;
1281
1282       buffer[highbyte] = 0xa0;  /* branch over move and disp */
1283       buffer[lowbyte] = 3;
1284       buffer[highbyte+2] = 0xd0 | JREG; /* Build mov insn */
1285       buffer[lowbyte+2] = 0x00;
1286
1287       buffer[highbyte+4] = 0;   /* space for 32 bit jump disp */
1288       buffer[lowbyte+4] = 0;
1289       buffer[highbyte+6] = 0;
1290       buffer[lowbyte+6] = 0;
1291
1292       buffer[highbyte+8] = 0x40 | JREG; /* Build jmp @JREG */
1293       buffer[lowbyte+8] = t ? 0xb : 0x2b;
1294
1295       buffer[highbyte+10] = 0x20; /* build nop */
1296       buffer[lowbyte+10] = 0x0b;
1297
1298       /* Make reloc for the long disp */
1299       fix_new (fragP,
1300                fragP->fr_fix + 4,
1301                4,
1302                fragP->fr_symbol,
1303                fragP->fr_offset,
1304                0,
1305                R_SH_IMM32);
1306       fragP->fr_fix += UNCOND32_LENGTH;
1307       fragP->fr_var = 0;
1308       donerelax = 1;
1309 #endif
1310
1311       break;
1312
1313     case C (COND_JUMP, COND12):
1314       /* A bcond won't fit, so turn it into a b!cond; bra disp; nop */
1315       {
1316         unsigned char *buffer =
1317           (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
1318         int highbyte = target_big_endian ? 0 : 1;
1319         int lowbyte = target_big_endian ? 1 : 0;
1320
1321         /* Toggle the true/false bit of the bcond.  */
1322         buffer[highbyte] ^= 0x2;
1323
1324         /* Build a relocation to six bytes farther on.  */
1325         subseg_change (seg, 0);
1326         fix_new (fragP, fragP->fr_fix, 2,
1327                  segment_info[seg].dot,
1328                  fragP->fr_address + fragP->fr_fix + 6,
1329                  1, R_SH_PCDISP8BY2);
1330
1331         /* Set up a jump instruction.  */
1332         buffer[highbyte + 2] = 0xa0;
1333         buffer[lowbyte + 2] = 0;
1334         fix_new (fragP, fragP->fr_fix + 2, 2, fragP->fr_symbol,
1335                  fragP->fr_offset, 1, R_SH_PCDISP);
1336
1337         /* Fill in a NOP instruction.  */
1338         buffer[highbyte + 4] = 0x0;
1339         buffer[lowbyte + 4] = 0x9;
1340
1341         fragP->fr_fix += 6;
1342         fragP->fr_var = 0;
1343         donerelax = 1;
1344       }
1345       break;
1346
1347     case C (COND_JUMP, COND32):
1348     case C (COND_JUMP, UNDEF_WORD_DISP):
1349       if (fragP->fr_symbol == NULL)
1350         as_bad ("at %0xlx, displacement overflows 8-bit field",
1351                 (unsigned long) fragP->fr_address);
1352       else
1353         as_bad ("at 0x%lx, displacement to %sdefined symbol %s overflows 8-bit field ",
1354                 (unsigned long) fragP->fr_address,
1355                 S_IS_DEFINED (fragP->fr_symbol) ? "" : "un",
1356                 S_GET_NAME (fragP->fr_symbol));
1357
1358 #if 0                           /* This code works, but generates poor code, and the compiler
1359                                    should never produce a sequence that requires it to be used.  */
1360
1361       /* A bcond won't fit and it won't go into a 12 bit
1362          displacement either, the code sequence looks like:
1363          b!cond foop
1364          mov.w @(n, PC), r14
1365          jmp  @r14
1366          nop
1367          .long where
1368          foop:
1369          */
1370
1371       buffer[0] ^= 0x2;         /* Toggle T/F bit */
1372 #define JREG 14
1373       buffer[1] = 5;            /* branch over mov, jump, nop and ptr */
1374       buffer[2] = 0xd0 | JREG;  /* Build mov insn */
1375       buffer[3] = 0x2;
1376       buffer[4] = 0x40 | JREG;  /* Build jmp @JREG */
1377       buffer[5] = 0x0b;
1378       buffer[6] = 0x20;         /* build nop */
1379       buffer[7] = 0x0b;
1380       buffer[8] = 0;            /* space for 32 bit jump disp */
1381       buffer[9] = 0;
1382       buffer[10] = 0;
1383       buffer[11] = 0;
1384       buffer[12] = 0;
1385       buffer[13] = 0;
1386       /* Make reloc for the long disp */
1387       fix_new (fragP,
1388                fragP->fr_fix + 8,
1389                4,
1390                fragP->fr_symbol,
1391                fragP->fr_offset,
1392                0,
1393                R_SH_IMM32);
1394       fragP->fr_fix += COND32_LENGTH;
1395       fragP->fr_var = 0;
1396       donerelax = 1;
1397 #endif
1398
1399       break;
1400
1401     default:
1402       abort ();
1403     }
1404
1405   if (donerelax && !sh_relax)
1406     as_warn ("Offset doesn't fit at 0x%lx, trying to get to %s+0x%lx",
1407              (unsigned long) fragP->fr_address,
1408              fragP->fr_symbol ? S_GET_NAME(fragP->fr_symbol): "",
1409              (unsigned long) fragP->fr_offset);
1410 }
1411
1412 valueT
1413 DEFUN (md_section_align, (seg, size),
1414        segT seg AND
1415        valueT size)
1416 {
1417   return ((size + (1 << section_alignment[(int) seg]) - 1)
1418           & (-1 << section_alignment[(int) seg]));
1419
1420 }
1421
1422 /* When relaxing, we need to output a reloc for any .align directive
1423    that requests alignment to a four byte boundary or larger.  */
1424
1425 void
1426 sh_handle_align (frag)
1427      fragS *frag;
1428 {
1429   if (sh_relax
1430       && frag->fr_type == rs_align
1431       && frag->fr_address + frag->fr_fix > 0
1432       && frag->fr_offset > 1)
1433     fix_new (frag, frag->fr_fix, 2, &abs_symbol, frag->fr_offset, 0,
1434              R_SH_ALIGN);
1435 }
1436
1437 /* This macro decides whether a particular reloc is an entry in a
1438    switch table.  It is used when relaxing, because the linker needs
1439    to know about all such entries so that it can adjust them if
1440    necessary.  */
1441
1442 #define SWITCH_TABLE(fix)                               \
1443   ((fix)->fx_addsy != NULL                              \
1444    && (fix)->fx_subsy != NULL                           \
1445    && S_GET_SEGMENT ((fix)->fx_addsy) == text_section   \
1446    && S_GET_SEGMENT ((fix)->fx_subsy) == text_section   \
1447    && ((fix)->fx_r_type == R_SH_IMM32                   \
1448        || (fix)->fx_r_type == R_SH_IMM16                \
1449        || ((fix)->fx_r_type == 0                        \
1450            && ((fix)->fx_size == 2                      \
1451                || (fix)->fx_size == 4))))
1452
1453 /* See whether we need to force a relocation into the output file.
1454    This is used to force out switch and PC relative relocations when
1455    relaxing.  */
1456
1457 int
1458 sh_force_relocation (fix)
1459      fixS *fix;
1460 {
1461   if (! sh_relax)
1462     return 0;
1463
1464   return (fix->fx_pcrel
1465           || SWITCH_TABLE (fix)
1466           || fix->fx_r_type == R_SH_COUNT
1467           || fix->fx_r_type == R_SH_ALIGN);
1468 }
1469
1470 /* Apply a fixup to the object file.  */
1471
1472 void
1473 md_apply_fix (fixP, val)
1474      fixS *fixP;
1475      long val;
1476 {
1477   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
1478   int lowbyte = target_big_endian ? 1 : 0;
1479   int highbyte = target_big_endian ? 0 : 1;
1480
1481   if (fixP->fx_r_type == 0)
1482     {
1483       if (fixP->fx_size == 2)
1484         fixP->fx_r_type = R_SH_IMM16;
1485       else if (fixP->fx_size == 4)
1486         fixP->fx_r_type = R_SH_IMM32;
1487       else if (fixP->fx_size == 1)
1488         fixP->fx_r_type = R_SH_IMM8;
1489       else
1490         abort ();
1491     }
1492
1493   switch (fixP->fx_r_type)
1494     {
1495     case R_SH_IMM4:
1496       *buf = (*buf & 0xf0) | (val & 0xf);
1497       break;
1498
1499     case R_SH_IMM4BY2:
1500       *buf = (*buf & 0xf0) | ((val >> 1) & 0xf);
1501       break;
1502
1503     case R_SH_IMM4BY4:
1504       *buf = (*buf & 0xf0) | ((val >> 2) & 0xf);
1505       break;
1506
1507     case R_SH_IMM8BY2:
1508       *buf = val >> 1;
1509       break;
1510
1511     case R_SH_IMM8BY4:
1512       *buf = val >> 2;
1513       break;
1514
1515     case R_SH_IMM8:
1516       *buf++ = val;
1517       break;
1518
1519     case R_SH_PCRELIMM8BY4:
1520       /* The lower two bits of the PC are cleared before the
1521          displacement is added in.  We can assume that the destination
1522          is on a 4 byte bounday.  If this instruction is also on a 4
1523          byte boundary, then we want
1524            (target - here) / 4
1525          and target - here is a multiple of 4.
1526          Otherwise, we are on a 2 byte boundary, and we want
1527            (target - (here - 2)) / 4
1528          and target - here is not a multiple of 4.  Computing
1529            (target - (here - 2)) / 4 == (target - here + 2) / 4
1530          works for both cases, since in the first case the addition of
1531          2 will be removed by the division.  target - here is in the
1532          variable val.  */
1533       val = (val + 2) / 4;
1534       if (val & ~0xff)
1535         as_bad_where (fixP->fx_file, fixP->fx_line, "pcrel too far");
1536       buf[lowbyte] = val;
1537       break;
1538
1539     case R_SH_PCRELIMM8BY2:
1540       val /= 2;
1541       if (val & ~0xff)
1542         as_bad_where (fixP->fx_file, fixP->fx_line, "pcrel too far");
1543       buf[lowbyte] = val;
1544       break;
1545
1546     case R_SH_PCDISP8BY2:
1547       val /= 2;
1548       if (val < -0x80 || val > 0x7f)
1549         as_bad_where (fixP->fx_file, fixP->fx_line, "pcrel too far");
1550       buf[lowbyte] = val;
1551       break;
1552
1553     case R_SH_PCDISP:
1554       val /= 2;
1555       if (val < -0x800 || val >= 0x7ff)
1556         as_bad_where (fixP->fx_file, fixP->fx_line, "pcrel too far");
1557       buf[lowbyte] = val & 0xff;
1558       buf[highbyte] |= (val >> 8) & 0xf;
1559       break;
1560
1561     case R_SH_IMM32:
1562       if (! target_big_endian)
1563         {
1564           *buf++ = val >> 0;
1565           *buf++ = val >> 8;
1566           *buf++ = val >> 16;
1567           *buf++ = val >> 24;
1568         }
1569       else
1570         {
1571           *buf++ = val >> 24;
1572           *buf++ = val >> 16;
1573           *buf++ = val >> 8;
1574           *buf++ = val >> 0;
1575         }
1576       break;
1577
1578     case R_SH_IMM16:
1579       if (! target_big_endian)
1580         {
1581           *buf++ = val >> 0;
1582           *buf++ = val >> 8;
1583         }
1584       else
1585         {
1586           *buf++ = val >> 8;
1587           *buf++ = val >> 0;
1588         }
1589       break;
1590
1591     case R_SH_USES:
1592       /* Pass the value into sh_coff_reloc_mangle.  */
1593       fixP->fx_addnumber = val;
1594       break;
1595
1596     case R_SH_COUNT:
1597     case R_SH_ALIGN:
1598       /* Nothing to do here.  */
1599       break;
1600
1601     default:
1602       abort ();
1603     }
1604 }
1605
1606 int md_long_jump_size;
1607
1608 /* Called just before address relaxation.  Return the length
1609    by which a fragment must grow to reach it's destination.  */
1610
1611 int
1612 md_estimate_size_before_relax (fragP, segment_type)
1613      register fragS *fragP;
1614      register segT segment_type;
1615 {
1616   switch (fragP->fr_subtype)
1617     {
1618     case C (UNCOND_JUMP, UNDEF_DISP):
1619       /* used to be a branch to somewhere which was unknown */
1620       if (!fragP->fr_symbol)
1621         {
1622           fragP->fr_subtype = C (UNCOND_JUMP, UNCOND12);
1623           fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length;
1624         }
1625       else if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
1626         {
1627           fragP->fr_subtype = C (UNCOND_JUMP, UNCOND12);
1628           fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length;
1629         }
1630       else
1631         {
1632           fragP->fr_subtype = C (UNCOND_JUMP, UNDEF_WORD_DISP);
1633           fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length;
1634           return md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length;
1635         }
1636       break;
1637
1638     default:
1639       abort ();
1640     case C (COND_JUMP, UNDEF_DISP):
1641       /* used to be a branch to somewhere which was unknown */
1642       if (fragP->fr_symbol
1643           && S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
1644         {
1645           /* Got a symbol and it's defined in this segment, become byte
1646              sized - maybe it will fix up */
1647           fragP->fr_subtype = C (COND_JUMP, COND8);
1648           fragP->fr_var = md_relax_table[C (COND_JUMP, COND8)].rlx_length;
1649         }
1650       else if (fragP->fr_symbol)
1651         {
1652           /* Its got a segment, but its not ours, so it will always be long */
1653           fragP->fr_subtype = C (COND_JUMP, UNDEF_WORD_DISP);
1654           fragP->fr_var = md_relax_table[C (COND_JUMP, COND32)].rlx_length;
1655           return md_relax_table[C (COND_JUMP, COND32)].rlx_length;
1656         }
1657       else
1658         {
1659           /* We know the abs value */
1660           fragP->fr_subtype = C (COND_JUMP, COND8);
1661           fragP->fr_var = md_relax_table[C (COND_JUMP, COND8)].rlx_length;
1662         }
1663
1664       break;
1665     }
1666   return fragP->fr_var;
1667 }
1668
1669 /* Put number into target byte order */
1670
1671 void
1672 md_number_to_chars (ptr, use, nbytes)
1673      char *ptr;
1674      valueT use;
1675      int nbytes;
1676 {
1677   if (! target_big_endian)
1678     number_to_chars_littleendian (ptr, use, nbytes);
1679   else
1680     number_to_chars_bigendian (ptr, use, nbytes);
1681 }
1682
1683 long
1684 md_pcrel_from (fixP)
1685      fixS *fixP;
1686 {
1687   return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address + 2;
1688 }
1689
1690 int
1691 tc_coff_sizemachdep (frag)
1692      fragS *frag;
1693 {
1694   return md_relax_table[frag->fr_subtype].rlx_length;
1695 }
1696
1697 /* When we align the .text section, insert the correct NOP pattern.  */
1698
1699 int
1700 sh_do_align (n, fill)
1701      int n;
1702      const char *fill;
1703 {
1704   if ((fill == NULL || *fill == 0)
1705       && (now_seg == text_section
1706 #ifdef BFD_ASSEMBLER
1707           || (now_seg->flags & SEC_CODE) != 0
1708 #endif
1709           || strcmp (obj_segment_name (now_seg), ".init") == 0))
1710     {
1711       static const unsigned char big_nop_pattern[] = { 0x00, 0x09 };
1712       static const unsigned char little_nop_pattern[] = { 0x09, 0x00 };
1713
1714       if (target_big_endian)
1715         frag_align_pattern (n, big_nop_pattern, sizeof big_nop_pattern);
1716       else
1717         frag_align_pattern (n, little_nop_pattern, sizeof little_nop_pattern);
1718       return 1;
1719     }
1720
1721   return 0;
1722 }
1723
1724 #ifdef OBJ_COFF
1725
1726 /* Adjust a reloc for the SH.  This is similar to the generic code,
1727    but does some minor tweaking.  */
1728
1729 void
1730 sh_coff_reloc_mangle (seg, fix, intr, paddr)
1731      segment_info_type *seg;
1732      fixS *fix;
1733      struct internal_reloc *intr;
1734      unsigned int paddr;
1735 {
1736   symbolS *symbol_ptr = fix->fx_addsy;
1737   symbolS *dot;
1738
1739   intr->r_vaddr = paddr + fix->fx_frag->fr_address + fix->fx_where;
1740
1741   if (! SWITCH_TABLE (fix))
1742     {
1743       intr->r_type = fix->fx_r_type;
1744       intr->r_offset = 0;
1745     }
1746   else
1747     {
1748       know (sh_relax);
1749
1750       if (fix->fx_r_type == R_SH_IMM16)
1751         intr->r_type = R_SH_SWITCH16;
1752       else if (fix->fx_r_type == R_SH_IMM32)
1753         intr->r_type = R_SH_SWITCH32;
1754       else
1755         abort ();
1756
1757       /* For a switch reloc, we set r_offset to the difference between
1758          the reloc address and the subtrahend.  When the linker is
1759          doing relaxing, it can use the determine the starting and
1760          ending points of the switch difference expression.  */
1761       intr->r_offset = intr->r_vaddr - S_GET_VALUE (fix->fx_subsy);
1762     }
1763
1764   /* PC relative relocs are always against the current section.  */
1765   if (symbol_ptr == NULL)
1766     {
1767       switch (fix->fx_r_type)
1768         {
1769         case R_SH_PCRELIMM8BY2:
1770         case R_SH_PCRELIMM8BY4:
1771         case R_SH_PCDISP8BY2:
1772         case R_SH_PCDISP:
1773         case R_SH_USES:
1774           symbol_ptr = seg->dot;
1775           break;
1776         default:
1777           break;
1778         }
1779     }
1780
1781   if (fix->fx_r_type == R_SH_USES)
1782     {
1783       /* We can't store the offset in the object file, since this
1784          reloc does not take up any space, so we store it in r_offset.
1785          The fx_addnumber field was set in md_apply_fix.  */
1786       intr->r_offset = fix->fx_addnumber;
1787     }
1788   else if (fix->fx_r_type == R_SH_COUNT)
1789     {
1790       /* We can't store the count in the object file, since this reloc
1791          does not take up any space, so we store it in r_offset.  The
1792          fx_offset field was set when the fixup was created in
1793          sh_coff_frob_file.  */
1794       intr->r_offset = fix->fx_offset;
1795       /* This reloc is always absolute.  */
1796       symbol_ptr = NULL;
1797     }
1798   else if (fix->fx_r_type == R_SH_ALIGN)
1799     {
1800       /* Store the alignment in the r_offset field.  */
1801       intr->r_offset = fix->fx_offset;
1802       /* This reloc is always absolute.  */
1803       symbol_ptr = NULL;
1804     }
1805
1806   /* Turn the segment of the symbol into an offset.  */
1807   if (symbol_ptr != NULL)
1808     {
1809       dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
1810       if (dot != NULL)
1811         intr->r_symndx = dot->sy_number;
1812       else
1813         intr->r_symndx = symbol_ptr->sy_number;
1814     }
1815   else
1816     intr->r_symndx = -1;
1817 }
1818
1819 #endif