gas/config/tc-sh.c

   1 /* tc-sh.c -- Assemble code for the Hitachi Super-H
   2
   3    Copyright (C) 1993, 94, 95, 1996 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           fixS *fscan;
1143           int iscan;
1144           int count;
1145
1146           if (fix->fx_r_type != R_SH_USES)
1147             continue;
1148
1149           /* The R_SH_USES reloc should refer to a defined local
1150              symbol in the same section.  */
1151           sym = fix->fx_addsy;
1152           if (sym == NULL
1153               || fix->fx_subsy != NULL
1154               || fix->fx_addnumber != 0
1155               || S_GET_SEGMENT (sym) != iseg
1156               || S_GET_STORAGE_CLASS (sym) == C_EXT)
1157             {
1158               as_warn_where (fix->fx_file, fix->fx_line,
1159                              ".uses does not refer to a local symbol in the same section");
1160               continue;
1161             }
1162
1163           /* Look through the fixups again, this time looking for one
1164              at the same location as sym.  */
1165           val = S_GET_VALUE (sym);
1166           for (fscan = segment_info[iseg].fix_root;
1167                fscan != NULL;
1168                fscan = fscan->fx_next)
1169             if (val == fscan->fx_frag->fr_address + fscan->fx_where)
1170               break;
1171           if (fscan == NULL)
1172             {
1173               as_warn_where (fix->fx_file, fix->fx_line,
1174                              "can't find fixup pointed to by .uses");
1175               continue;
1176             }
1177
1178           if (fscan->fx_tcbit)
1179             {
1180               /* We've already done this one.  */
1181               continue;
1182             }
1183
1184           /* fscan should also be a fixup to a local symbol in the same
1185              section.  */
1186           sym = fscan->fx_addsy;
1187           if (sym == NULL
1188               || fscan->fx_subsy != NULL
1189               || fscan->fx_addnumber != 0
1190               || S_GET_SEGMENT (sym) != iseg
1191               || S_GET_STORAGE_CLASS (sym) == C_EXT)
1192             {
1193               as_warn_where (fix->fx_file, fix->fx_line,
1194                              ".uses target does not refer to a local symbol in the same section");
1195               continue;
1196             }
1197
1198           /* Now we look through all the fixups of all the sections,
1199              counting the number of times we find a reference to sym.  */
1200           count = 0;
1201           for (iscan = SEG_E0; iscan < SEG_UNKNOWN; iscan++)
1202             {
1203               for (fscan = segment_info[iscan].fix_root;
1204                    fscan != NULL;
1205                    fscan = fscan->fx_next)
1206                 {
1207                   if (fscan->fx_addsy == sym)
1208                     {
1209                       ++count;
1210                       fscan->fx_tcbit = 1;
1211                     }
1212                 }
1213             }
1214
1215           if (count < 1)
1216             abort ();
1217
1218           /* Generate a R_SH_COUNT fixup at the location of sym.  We
1219              have already adjusted the value of sym to include the
1220              fragment address, so we undo that adjustment here.  */
1221           subseg_change (iseg, 0);
1222           fix_new (sym->sy_frag, S_GET_VALUE (sym) - sym->sy_frag->fr_address,
1223                    4, &abs_symbol, count, 0, R_SH_COUNT);
1224         }
1225     }
1226 }
1227
1228 /* Called after relaxing.  Set the correct sizes of the fragments, and
1229    create relocs so that md_apply_fix will fill in the correct values.  */
1230
1231 void
1232 md_convert_frag (headers, seg, fragP)
1233      object_headers *headers;
1234      segT seg;
1235      fragS *fragP;
1236 {
1237   int donerelax = 0;
1238
1239   switch (fragP->fr_subtype)
1240     {
1241     case C (COND_JUMP, COND8):
1242       subseg_change (seg, 0);
1243       fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
1244                1, R_SH_PCDISP8BY2);
1245       fragP->fr_fix += 2;
1246       fragP->fr_var = 0;
1247       break;
1248
1249     case C (UNCOND_JUMP, UNCOND12):
1250       subseg_change (seg, 0);
1251       fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
1252                1, R_SH_PCDISP);
1253       fragP->fr_fix += 2;
1254       fragP->fr_var = 0;
1255       break;
1256
1257     case C (UNCOND_JUMP, UNCOND32):
1258     case C (UNCOND_JUMP, UNDEF_WORD_DISP):
1259       if (fragP->fr_symbol == NULL)
1260         as_bad ("at 0x%lx, displacement overflows 12-bit field",
1261                 (unsigned long) fragP->fr_address);
1262       else
1263         as_bad ("at 0x%lx, displacement to %sdefined symbol %s overflows 12-bit field",
1264                 (unsigned long) fragP->fr_address,
1265                 S_IS_DEFINED (fragP->fr_symbol) ? "" : "un",
1266                 S_GET_NAME (fragP->fr_symbol));
1267
1268 #if 0                           /* This code works, but generates poor code and the compiler
1269                                    should never produce a sequence that requires it to be used.  */
1270
1271       /* A jump wont fit in 12 bits, make code which looks like
1272          bra foo
1273          mov.w @(0, PC), r14
1274          .long disp
1275          foo: bra @r14
1276          */
1277       int t = buffer[0] & 0x10;
1278
1279       buffer[highbyte] = 0xa0;  /* branch over move and disp */
1280       buffer[lowbyte] = 3;
1281       buffer[highbyte+2] = 0xd0 | JREG; /* Build mov insn */
1282       buffer[lowbyte+2] = 0x00;
1283
1284       buffer[highbyte+4] = 0;   /* space for 32 bit jump disp */
1285       buffer[lowbyte+4] = 0;
1286       buffer[highbyte+6] = 0;
1287       buffer[lowbyte+6] = 0;
1288
1289       buffer[highbyte+8] = 0x40 | JREG; /* Build jmp @JREG */
1290       buffer[lowbyte+8] = t ? 0xb : 0x2b;
1291
1292       buffer[highbyte+10] = 0x20; /* build nop */
1293       buffer[lowbyte+10] = 0x0b;
1294
1295       /* Make reloc for the long disp */
1296       fix_new (fragP,
1297                fragP->fr_fix + 4,
1298                4,
1299                fragP->fr_symbol,
1300                fragP->fr_offset,
1301                0,
1302                R_SH_IMM32);
1303       fragP->fr_fix += UNCOND32_LENGTH;
1304       fragP->fr_var = 0;
1305       donerelax = 1;
1306 #endif
1307
1308       break;
1309
1310     case C (COND_JUMP, COND12):
1311       /* A bcond won't fit, so turn it into a b!cond; bra disp; nop */
1312       {
1313         unsigned char *buffer =
1314           (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
1315         int highbyte = target_big_endian ? 0 : 1;
1316         int lowbyte = target_big_endian ? 1 : 0;
1317
1318         /* Toggle the true/false bit of the bcond.  */
1319         buffer[highbyte] ^= 0x2;
1320
1321         /* Build a relocation to six bytes farther on.  */
1322         subseg_change (seg, 0);
1323         fix_new (fragP, fragP->fr_fix, 2,
1324                  segment_info[seg].dot,
1325                  fragP->fr_address + fragP->fr_fix + 6,
1326                  1, R_SH_PCDISP8BY2);
1327
1328         /* Set up a jump instruction.  */
1329         buffer[highbyte + 2] = 0xa0;
1330         buffer[lowbyte + 2] = 0;
1331         fix_new (fragP, fragP->fr_fix + 2, 2, fragP->fr_symbol,
1332                  fragP->fr_offset, 1, R_SH_PCDISP);
1333
1334         /* Fill in a NOP instruction.  */
1335         buffer[highbyte + 4] = 0x0;
1336         buffer[lowbyte + 4] = 0x9;
1337
1338         fragP->fr_fix += 6;
1339         fragP->fr_var = 0;
1340         donerelax = 1;
1341       }
1342       break;
1343
1344     case C (COND_JUMP, COND32):
1345     case C (COND_JUMP, UNDEF_WORD_DISP):
1346       if (fragP->fr_symbol == NULL)
1347         as_bad ("at %0xlx, displacement overflows 8-bit field",
1348                 (unsigned long) fragP->fr_address);
1349       else
1350         as_bad ("at 0x%lx, displacement to %sdefined symbol %s overflows 8-bit field ",
1351                 (unsigned long) fragP->fr_address,
1352                 S_IS_DEFINED (fragP->fr_symbol) ? "" : "un",
1353                 S_GET_NAME (fragP->fr_symbol));
1354
1355 #if 0                           /* This code works, but generates poor code, and the compiler
1356                                    should never produce a sequence that requires it to be used.  */
1357
1358       /* A bcond won't fit and it won't go into a 12 bit
1359          displacement either, the code sequence looks like:
1360          b!cond foop
1361          mov.w @(n, PC), r14
1362          jmp  @r14
1363          nop
1364          .long where
1365          foop:
1366          */
1367
1368       buffer[0] ^= 0x2;         /* Toggle T/F bit */
1369 #define JREG 14
1370       buffer[1] = 5;            /* branch over mov, jump, nop and ptr */
1371       buffer[2] = 0xd0 | JREG;  /* Build mov insn */
1372       buffer[3] = 0x2;
1373       buffer[4] = 0x40 | JREG;  /* Build jmp @JREG */
1374       buffer[5] = 0x0b;
1375       buffer[6] = 0x20;         /* build nop */
1376       buffer[7] = 0x0b;
1377       buffer[8] = 0;            /* space for 32 bit jump disp */
1378       buffer[9] = 0;
1379       buffer[10] = 0;
1380       buffer[11] = 0;
1381       buffer[12] = 0;
1382       buffer[13] = 0;
1383       /* Make reloc for the long disp */
1384       fix_new (fragP,
1385                fragP->fr_fix + 8,
1386                4,
1387                fragP->fr_symbol,
1388                fragP->fr_offset,
1389                0,
1390                R_SH_IMM32);
1391       fragP->fr_fix += COND32_LENGTH;
1392       fragP->fr_var = 0;
1393       donerelax = 1;
1394 #endif
1395
1396       break;
1397
1398     default:
1399       abort ();
1400     }
1401
1402   if (donerelax && !sh_relax)
1403     as_warn ("Offset doesn't fit at 0x%lx, trying to get to %s+0x%lx",
1404              (unsigned long) fragP->fr_address,
1405              fragP->fr_symbol ? S_GET_NAME(fragP->fr_symbol): "",
1406              (unsigned long) fragP->fr_offset);
1407 }
1408
1409 valueT
1410 DEFUN (md_section_align, (seg, size),
1411        segT seg AND
1412        valueT size)
1413 {
1414   return ((size + (1 << section_alignment[(int) seg]) - 1)
1415           & (-1 << section_alignment[(int) seg]));
1416
1417 }
1418
1419 /* When relaxing, we need to output a reloc for any .align directive
1420    that requests alignment to a four byte boundary or larger.  */
1421
1422 void
1423 sh_handle_align (frag)
1424      fragS *frag;
1425 {
1426   if (sh_relax
1427       && frag->fr_type == rs_align
1428       && frag->fr_address + frag->fr_fix > 0
1429       && frag->fr_offset > 1
1430       && now_seg != bss_section)
1431     fix_new (frag, frag->fr_fix, 2, &abs_symbol, frag->fr_offset, 0,
1432              R_SH_ALIGN);
1433 }
1434
1435 /* This macro decides whether a particular reloc is an entry in a
1436    switch table.  It is used when relaxing, because the linker needs
1437    to know about all such entries so that it can adjust them if
1438    necessary.  */
1439
1440 #define SWITCH_TABLE(fix)                               \
1441   ((fix)->fx_addsy != NULL                              \
1442    && (fix)->fx_subsy != NULL                           \
1443    && S_GET_SEGMENT ((fix)->fx_addsy) == text_section   \
1444    && S_GET_SEGMENT ((fix)->fx_subsy) == text_section   \
1445    && ((fix)->fx_r_type == R_SH_IMM32                   \
1446        || (fix)->fx_r_type == R_SH_IMM16                \
1447        || ((fix)->fx_r_type == 0                        \
1448            && ((fix)->fx_size == 2                      \
1449                || (fix)->fx_size == 4))))
1450
1451 /* See whether we need to force a relocation into the output file.
1452    This is used to force out switch and PC relative relocations when
1453    relaxing.  */
1454
1455 int
1456 sh_force_relocation (fix)
1457      fixS *fix;
1458 {
1459   if (! sh_relax)
1460     return 0;
1461
1462   return (fix->fx_pcrel
1463           || SWITCH_TABLE (fix)
1464           || fix->fx_r_type == R_SH_COUNT
1465           || fix->fx_r_type == R_SH_ALIGN);
1466 }
1467
1468 /* Apply a fixup to the object file.  */
1469
1470 void
1471 md_apply_fix (fixP, val)
1472      fixS *fixP;
1473      long val;
1474 {
1475   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
1476   int lowbyte = target_big_endian ? 1 : 0;
1477   int highbyte = target_big_endian ? 0 : 1;
1478
1479   if (fixP->fx_r_type == 0)
1480     {
1481       if (fixP->fx_size == 2)
1482         fixP->fx_r_type = R_SH_IMM16;
1483       else if (fixP->fx_size == 4)
1484         fixP->fx_r_type = R_SH_IMM32;
1485       else if (fixP->fx_size == 1)
1486         fixP->fx_r_type = R_SH_IMM8;
1487       else
1488         abort ();
1489     }
1490
1491   switch (fixP->fx_r_type)
1492     {
1493     case R_SH_IMM4:
1494       *buf = (*buf & 0xf0) | (val & 0xf);
1495       break;
1496
1497     case R_SH_IMM4BY2:
1498       *buf = (*buf & 0xf0) | ((val >> 1) & 0xf);
1499       break;
1500
1501     case R_SH_IMM4BY4:
1502       *buf = (*buf & 0xf0) | ((val >> 2) & 0xf);
1503       break;
1504
1505     case R_SH_IMM8BY2:
1506       *buf = val >> 1;
1507       break;
1508
1509     case R_SH_IMM8BY4:
1510       *buf = val >> 2;
1511       break;
1512
1513     case R_SH_IMM8:
1514       *buf++ = val;
1515       break;
1516
1517     case R_SH_PCRELIMM8BY4:
1518       /* The lower two bits of the PC are cleared before the
1519          displacement is added in.  We can assume that the destination
1520          is on a 4 byte bounday.  If this instruction is also on a 4
1521          byte boundary, then we want
1522            (target - here) / 4
1523          and target - here is a multiple of 4.
1524          Otherwise, we are on a 2 byte boundary, and we want
1525            (target - (here - 2)) / 4
1526          and target - here is not a multiple of 4.  Computing
1527            (target - (here - 2)) / 4 == (target - here + 2) / 4
1528          works for both cases, since in the first case the addition of
1529          2 will be removed by the division.  target - here is in the
1530          variable val.  */
1531       val = (val + 2) / 4;
1532       if (val & ~0xff)
1533         as_bad_where (fixP->fx_file, fixP->fx_line, "pcrel too far");
1534       buf[lowbyte] = val;
1535       break;
1536
1537     case R_SH_PCRELIMM8BY2:
1538       val /= 2;
1539       if (val & ~0xff)
1540         as_bad_where (fixP->fx_file, fixP->fx_line, "pcrel too far");
1541       buf[lowbyte] = val;
1542       break;
1543
1544     case R_SH_PCDISP8BY2:
1545       val /= 2;
1546       if (val < -0x80 || val > 0x7f)
1547         as_bad_where (fixP->fx_file, fixP->fx_line, "pcrel too far");
1548       buf[lowbyte] = val;
1549       break;
1550
1551     case R_SH_PCDISP:
1552       val /= 2;
1553       if (val < -0x800 || val >= 0x7ff)
1554         as_bad_where (fixP->fx_file, fixP->fx_line, "pcrel too far");
1555       buf[lowbyte] = val & 0xff;
1556       buf[highbyte] |= (val >> 8) & 0xf;
1557       break;
1558
1559     case R_SH_IMM32:
1560       if (! target_big_endian)
1561         {
1562           *buf++ = val >> 0;
1563           *buf++ = val >> 8;
1564           *buf++ = val >> 16;
1565           *buf++ = val >> 24;
1566         }
1567       else
1568         {
1569           *buf++ = val >> 24;
1570           *buf++ = val >> 16;
1571           *buf++ = val >> 8;
1572           *buf++ = val >> 0;
1573         }
1574       break;
1575
1576     case R_SH_IMM16:
1577       if (! target_big_endian)
1578         {
1579           *buf++ = val >> 0;
1580           *buf++ = val >> 8;
1581         }
1582       else
1583         {
1584           *buf++ = val >> 8;
1585           *buf++ = val >> 0;
1586         }
1587       break;
1588
1589     case R_SH_USES:
1590       /* Pass the value into sh_coff_reloc_mangle.  */
1591       fixP->fx_addnumber = val;
1592       break;
1593
1594     case R_SH_COUNT:
1595     case R_SH_ALIGN:
1596       /* Nothing to do here.  */
1597       break;
1598
1599     default:
1600       abort ();
1601     }
1602 }
1603
1604 int md_long_jump_size;
1605
1606 /* Called just before address relaxation.  Return the length
1607    by which a fragment must grow to reach it's destination.  */
1608
1609 int
1610 md_estimate_size_before_relax (fragP, segment_type)
1611      register fragS *fragP;
1612      register segT segment_type;
1613 {
1614   switch (fragP->fr_subtype)
1615     {
1616     case C (UNCOND_JUMP, UNDEF_DISP):
1617       /* used to be a branch to somewhere which was unknown */
1618       if (!fragP->fr_symbol)
1619         {
1620           fragP->fr_subtype = C (UNCOND_JUMP, UNCOND12);
1621           fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length;
1622         }
1623       else if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
1624         {
1625           fragP->fr_subtype = C (UNCOND_JUMP, UNCOND12);
1626           fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length;
1627         }
1628       else
1629         {
1630           fragP->fr_subtype = C (UNCOND_JUMP, UNDEF_WORD_DISP);
1631           fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length;
1632           return md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length;
1633         }
1634       break;
1635
1636     default:
1637       abort ();
1638     case C (COND_JUMP, UNDEF_DISP):
1639       /* used to be a branch to somewhere which was unknown */
1640       if (fragP->fr_symbol
1641           && S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
1642         {
1643           /* Got a symbol and it's defined in this segment, become byte
1644              sized - maybe it will fix up */
1645           fragP->fr_subtype = C (COND_JUMP, COND8);
1646           fragP->fr_var = md_relax_table[C (COND_JUMP, COND8)].rlx_length;
1647         }
1648       else if (fragP->fr_symbol)
1649         {
1650           /* Its got a segment, but its not ours, so it will always be long */
1651           fragP->fr_subtype = C (COND_JUMP, UNDEF_WORD_DISP);
1652           fragP->fr_var = md_relax_table[C (COND_JUMP, COND32)].rlx_length;
1653           return md_relax_table[C (COND_JUMP, COND32)].rlx_length;
1654         }
1655       else
1656         {
1657           /* We know the abs value */
1658           fragP->fr_subtype = C (COND_JUMP, COND8);
1659           fragP->fr_var = md_relax_table[C (COND_JUMP, COND8)].rlx_length;
1660         }
1661
1662       break;
1663     }
1664   return fragP->fr_var;
1665 }
1666
1667 /* Put number into target byte order */
1668
1669 void
1670 md_number_to_chars (ptr, use, nbytes)
1671      char *ptr;
1672      valueT use;
1673      int nbytes;
1674 {
1675   if (! target_big_endian)
1676     number_to_chars_littleendian (ptr, use, nbytes);
1677   else
1678     number_to_chars_bigendian (ptr, use, nbytes);
1679 }
1680
1681 long
1682 md_pcrel_from (fixP)
1683      fixS *fixP;
1684 {
1685   return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address + 2;
1686 }
1687
1688 int
1689 tc_coff_sizemachdep (frag)
1690      fragS *frag;
1691 {
1692   return md_relax_table[frag->fr_subtype].rlx_length;
1693 }
1694
1695 /* When we align the .text section, insert the correct NOP pattern.  */
1696
1697 int
1698 sh_do_align (n, fill, len)
1699      int n;
1700      const char *fill;
1701      int len;
1702 {
1703   if ((fill == NULL || (*fill == 0 && len == 1))
1704       && (now_seg == text_section
1705 #ifdef BFD_ASSEMBLER
1706           || (now_seg->flags & SEC_CODE) != 0
1707 #endif
1708           || strcmp (obj_segment_name (now_seg), ".init") == 0))
1709     {
1710       static const unsigned char big_nop_pattern[] = { 0x00, 0x09 };
1711       static const unsigned char little_nop_pattern[] = { 0x09, 0x00 };
1712
1713       /* First align to a 2 byte boundary, in case there is an odd
1714          .byte.  */
1715       frag_align (2, 0);
1716       if (target_big_endian)
1717         frag_align_pattern (n, big_nop_pattern, sizeof big_nop_pattern);
1718       else
1719         frag_align_pattern (n, little_nop_pattern, sizeof little_nop_pattern);
1720       return 1;
1721     }
1722
1723   return 0;
1724 }
1725
1726 #ifdef OBJ_COFF
1727
1728 /* Adjust a reloc for the SH.  This is similar to the generic code,
1729    but does some minor tweaking.  */
1730
1731 void
1732 sh_coff_reloc_mangle (seg, fix, intr, paddr)
1733      segment_info_type *seg;
1734      fixS *fix;
1735      struct internal_reloc *intr;
1736      unsigned int paddr;
1737 {
1738   symbolS *symbol_ptr = fix->fx_addsy;
1739   symbolS *dot;
1740
1741   intr->r_vaddr = paddr + fix->fx_frag->fr_address + fix->fx_where;
1742
1743   if (! SWITCH_TABLE (fix))
1744     {
1745       intr->r_type = fix->fx_r_type;
1746       intr->r_offset = 0;
1747     }
1748   else
1749     {
1750       know (sh_relax);
1751
1752       if (fix->fx_r_type == R_SH_IMM16)
1753         intr->r_type = R_SH_SWITCH16;
1754       else if (fix->fx_r_type == R_SH_IMM32)
1755         intr->r_type = R_SH_SWITCH32;
1756       else
1757         abort ();
1758
1759       /* For a switch reloc, we set r_offset to the difference between
1760          the reloc address and the subtrahend.  When the linker is
1761          doing relaxing, it can use the determine the starting and
1762          ending points of the switch difference expression.  */
1763       intr->r_offset = intr->r_vaddr - S_GET_VALUE (fix->fx_subsy);
1764     }
1765
1766   /* PC relative relocs are always against the current section.  */
1767   if (symbol_ptr == NULL)
1768     {
1769       switch (fix->fx_r_type)
1770         {
1771         case R_SH_PCRELIMM8BY2:
1772         case R_SH_PCRELIMM8BY4:
1773         case R_SH_PCDISP8BY2:
1774         case R_SH_PCDISP:
1775         case R_SH_USES:
1776           symbol_ptr = seg->dot;
1777           break;
1778         default:
1779           break;
1780         }
1781     }
1782
1783   if (fix->fx_r_type == R_SH_USES)
1784     {
1785       /* We can't store the offset in the object file, since this
1786          reloc does not take up any space, so we store it in r_offset.
1787          The fx_addnumber field was set in md_apply_fix.  */
1788       intr->r_offset = fix->fx_addnumber;
1789     }
1790   else if (fix->fx_r_type == R_SH_COUNT)
1791     {
1792       /* We can't store the count in the object file, since this reloc
1793          does not take up any space, so we store it in r_offset.  The
1794          fx_offset field was set when the fixup was created in
1795          sh_coff_frob_file.  */
1796       intr->r_offset = fix->fx_offset;
1797       /* This reloc is always absolute.  */
1798       symbol_ptr = NULL;
1799     }
1800   else if (fix->fx_r_type == R_SH_ALIGN)
1801     {
1802       /* Store the alignment in the r_offset field.  */
1803       intr->r_offset = fix->fx_offset;
1804       /* This reloc is always absolute.  */
1805       symbol_ptr = NULL;
1806     }
1807
1808   /* Turn the segment of the symbol into an offset.  */
1809   if (symbol_ptr != NULL)
1810     {
1811       dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
1812       if (dot != NULL)
1813         intr->r_symndx = dot->sy_number;
1814       else
1815         intr->r_symndx = symbol_ptr->sy_number;
1816     }
1817   else
1818     intr->r_symndx = -1;
1819 }
1820
1821 #endif