gas/config/tc-sh.c

   1 /* tc-sh.c -- Assemble code for the Hitachi Super-H
   2
   3    Copyright (C) 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /*
  22    Written By Steve Chamberlain
  23    sac@cygnus.com
  24  */
  25
  26 #include <stdio.h>
  27 #include "as.h"
  28 #include "bfd.h"
  29 #include "subsegs.h"
  30 #define DEFINE_TABLE
  31 #include "../opcodes/sh-opc.h"
  32 #include <ctype.h>
  33
  34 const char comment_chars[] = "!";
  35 const char line_separator_chars[] = ";";
  36 const char line_comment_chars[] = "!";
  37
  38 /* This table describes all the machine specific pseudo-ops the assembler
  39    has to support.  The fields are:
  40    pseudo-op name without dot
  41    function to call to execute this pseudo-op
  42    Integer arg to pass to the function
  43  */
  44
  45 void cons ();
  46 void s_align_bytes ();
  47
  48 const pseudo_typeS md_pseudo_table[] =
  49 {
  50   {"int", cons, 4},
  51   {"word", cons, 2},
  52   {"form", listing_psize, 0},
  53   {"heading", listing_title, 0},
  54   {"import", s_ignore, 0},
  55   {"page", listing_eject, 0},
  56   {"program", s_ignore, 0},
  57   {0, 0, 0}
  58 };
  59
  60 /*int md_reloc_size; */
  61
  62 static int relax;               /* set if -relax seen */
  63
  64 const char EXP_CHARS[] = "eE";
  65
  66 /* Chars that mean this number is a floating point constant */
  67 /* As in 0f12.456 */
  68 /* or    0d1.2345e12 */
  69 const char FLT_CHARS[] = "rRsSfFdDxXpP";
  70
  71 #define C(a,b) ENCODE_RELAX(a,b)
  72
  73 #define JREG 14                 /* Register used as a temp when relaxing */
  74 #define ENCODE_RELAX(what,length) (((what) << 4) + (length))
  75 #define GET_WHAT(x) ((x>>4))
  76
  77 /* These are the two types of relaxable instrction */
  78 #define COND_JUMP 1
  79 #define UNCOND_JUMP  2
  80
  81 #define UNDEF_DISP 0
  82 #define COND8  1
  83 #define COND12 2
  84 #define COND32 3
  85 #define UNCOND12 1
  86 #define UNCOND32 2
  87 #define UNDEF_WORD_DISP 4
  88 #define END 5
  89
  90 #define UNCOND12 1
  91 #define UNCOND32 2
  92
  93 #define COND8_F 254
  94 #define COND8_M -256
  95 #define COND8_LENGTH 2
  96 #define COND12_F (4094 - 4)     /* -4 since there are two extra */
  97 /* instructions needed */
  98 #define COND12_M -4096
  99 #define COND12_LENGTH 6
 100 #define COND32_F (1<<30)
 101 #define COND32_M -(1<<30)
 102 #define COND32_LENGTH 14
 103
 104 #define COND8_RANGE(x) ((x) > COND8_M && (x) < COND8_F)
 105 #define COND12_RANGE(x) ((x) > COND12_M && (x) < COND12_F)
 106
 107 #define UNCOND12_F 4094
 108 #define UNCOND12_M -4096
 109 #define UNCOND12_LENGTH 2
 110
 111 #define UNCOND32_F (1<<30)
 112 #define UNCOND32_M -(1<<30)
 113 #define UNCOND32_LENGTH 14
 114
 115
 116 const relax_typeS md_relax_table[C (END, 0)];
 117
 118 static struct hash_control *opcode_hash_control;        /* Opcode mnemonics */
 119
 120 /*
 121    This function is called once, at assembler startup time.  This should
 122    set up all the tables, etc that the MD part of the assembler needs
 123  */
 124
 125 void
 126 md_begin ()
 127 {
 128   sh_opcode_info *opcode;
 129   char *prev_name = "";
 130
 131   opcode_hash_control = hash_new ();
 132
 133   /* Insert unique names into hash table */
 134   for (opcode = sh_table; opcode->name; opcode++)
 135     {
 136       if (strcmp (prev_name, opcode->name))
 137         {
 138           prev_name = opcode->name;
 139           hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
 140         }
 141       else
 142         {
 143           /* Make all the opcodes with the same name point to the same
 144              string */
 145           opcode->name = prev_name;
 146         }
 147     }
 148
 149   /* Initialize the relax table */
 150   md_relax_table[C (COND_JUMP, COND8)].rlx_forward = COND8_F;
 151   md_relax_table[C (COND_JUMP, COND8)].rlx_backward = COND8_M;
 152   md_relax_table[C (COND_JUMP, COND8)].rlx_length = COND8_LENGTH;
 153   md_relax_table[C (COND_JUMP, COND8)].rlx_more = C (COND_JUMP, COND12);
 154
 155   md_relax_table[C (COND_JUMP, COND12)].rlx_forward = COND12_F;
 156   md_relax_table[C (COND_JUMP, COND12)].rlx_backward = COND12_M;
 157   md_relax_table[C (COND_JUMP, COND12)].rlx_length = COND12_LENGTH;
 158   md_relax_table[C (COND_JUMP, COND12)].rlx_more = C (COND_JUMP, COND32);
 159
 160   md_relax_table[C (COND_JUMP, COND32)].rlx_forward = COND32_F;
 161   md_relax_table[C (COND_JUMP, COND32)].rlx_backward = COND32_M;
 162   md_relax_table[C (COND_JUMP, COND32)].rlx_length = COND32_LENGTH;
 163   md_relax_table[C (COND_JUMP, COND32)].rlx_more = 0;
 164
 165
 166   md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_forward = UNCOND12_F;
 167   md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_backward = UNCOND12_M;
 168   md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length = UNCOND12_LENGTH;
 169   md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_more = C (UNCOND_JUMP, UNCOND32);
 170
 171   md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_forward = UNCOND32_F;
 172   md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_backward = UNCOND32_M;
 173   md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length = UNCOND32_LENGTH;
 174   md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_more = 0;
 175
 176
 177 }
 178
 179 static int reg_m;
 180 static int reg_n;
 181 static expressionS immediate;   /* absolute expression */
 182
 183 typedef struct
 184   {
 185     sh_arg_type type;
 186     int reg;
 187   }
 188
 189 sh_operand_info;
 190
 191 /* try and parse a reg name, returns number of chars consumed */
 192 static int
 193 parse_reg (src, mode, reg)
 194      char *src;
 195      int *mode;
 196      int *reg;
 197 {
 198   if (src[0] == 'r')
 199     {
 200       if (src[1] == '1')
 201         {
 202           if (src[2] >= '0' && src[2] <= '5')
 203             {
 204               *mode = A_REG_N;
 205               *reg = 10 + src[2] - '0';
 206               return 3;
 207             }
 208         }
 209       if (src[1] >= '0' && src[1] <= '9')
 210         {
 211           *mode = A_REG_N;
 212           *reg = (src[1] - '0');
 213           return 2;
 214         }
 215     }
 216
 217   if (src[0] == 's' && src[1] == 'r')
 218     {
 219       *mode = A_SR;
 220       return 2;
 221     }
 222
 223   if (src[0] == 's' && src[1] == 'p')
 224     {
 225       *mode = A_REG_N;
 226       *reg = 15;
 227       return 2;
 228     }
 229
 230   if (src[0] == 'p' && src[1] == 'r')
 231     {
 232       *mode = A_PR;
 233       return 2;
 234     }
 235   if (src[0] == 'p' && src[1] == 'c')
 236     {
 237       *mode = A_DISP_PC;
 238       return 2;
 239     }
 240   if (src[0] == 'g' && src[1] == 'b' && src[2] == 'r')
 241     {
 242       *mode = A_GBR;
 243       return 3;
 244     }
 245   if (src[0] == 'v' && src[1] == 'b' && src[2] == 'r')
 246     {
 247       *mode = A_VBR;
 248       return 3;
 249     }
 250
 251   if (src[0] == 'm' && src[1] == 'a' && src[2] == 'c')
 252     {
 253       if (src[3] == 'l')
 254         {
 255           *mode = A_MACL;
 256           return 4;
 257         }
 258       if (src[3] == 'h')
 259         {
 260           *mode = A_MACH;
 261           return 4;
 262         }
 263     }
 264
 265   return 0;
 266 }
 267
 268 static symbolS *dot()
 269 {
 270   const char *fake;
 271
 272   /* JF: '.' is pseudo symbol with value of current location
 273      in current segment.  */
 274   fake = FAKE_LABEL_NAME;
 275   return  symbol_new (fake,
 276                       now_seg,
 277                       (valueT) frag_now_fix (),
 278                       frag_now);
 279
 280 }
 281
 282
 283 static
 284 char *
 285 parse_exp (s)
 286      char *s;
 287 {
 288   char *save;
 289   char *new;
 290
 291   save = input_line_pointer;
 292   input_line_pointer = s;
 293   expression (&immediate);
 294   if (immediate.X_op == O_absent)
 295     as_bad ("missing operand");
 296   new = input_line_pointer;
 297   input_line_pointer = save;
 298   return new;
 299 }
 300
 301
 302 /* The many forms of operand:
 303
 304    Rn                   Register direct
 305    @Rn                  Register indirect
 306    @Rn+                 Autoincrement
 307    @-Rn                 Autodecrement
 308    @(disp:4,Rn)
 309    @(disp:8,GBR)
 310    @(disp:8,PC)
 311
 312    @(R0,Rn)
 313    @(R0,GBR)
 314
 315    disp:8
 316    disp:12
 317    #imm8
 318    pr, gbr, vbr, macl, mach
 319
 320  */
 321
 322 static
 323 char *
 324 parse_at (src, op)
 325      char *src;
 326      sh_operand_info *op;
 327 {
 328   int len;
 329   int mode;
 330   src++;
 331   if (src[0] == '-')
 332     {
 333       /* Must be predecrement */
 334       src++;
 335
 336       len = parse_reg (src, &mode, &(op->reg));
 337       if (mode != A_REG_N)
 338         as_bad ("illegal register after @-");
 339
 340       op->type = A_DEC_N;
 341       src += len;
 342     }
 343   else if (src[0] == '(')
 344     {
 345       /* Could be @(disp, rn), @(disp, gbr), @(disp, pc),  @(r0, gbr) or
 346          @(r0, rn) */
 347       src++;
 348       len = parse_reg (src, &mode, &(op->reg));
 349       if (len && mode == A_REG_N)
 350         {
 351           src += len;
 352           if (op->reg != 0)
 353             {
 354               as_bad ("must be @(r0,...)");
 355             }
 356           if (src[0] == ',')
 357             src++;
 358           /* Now can be rn or gbr */
 359           len = parse_reg (src, &mode, &(op->reg));
 360           if (mode == A_GBR)
 361             {
 362               op->type = A_R0_GBR;
 363             }
 364           else if (mode == A_REG_N)
 365             {
 366               op->type = A_IND_R0_REG_N;
 367             }
 368           else
 369             {
 370               as_bad ("syntax error in @(r0,...)");
 371             }
 372         }
 373       else
 374         {
 375           /* Must be an @(disp,.. thing) */
 376           src = parse_exp (src);
 377           if (src[0] == ',')
 378             src++;
 379           /* Now can be rn, gbr or pc */
 380           len = parse_reg (src, &mode, &op->reg);
 381           if (len)
 382             {
 383               if (mode == A_REG_N)
 384                 {
 385                   op->type = A_DISP_REG_N;
 386                 }
 387               else if (mode == A_GBR)
 388                 {
 389                   op->type = A_DISP_GBR;
 390                 }
 391               else if (mode == A_DISP_PC)
 392                 {
 393                   /* Turn a plain @(4,pc) into @(.+4,pc) */
 394                   if (immediate.X_op == O_constant) {
 395                     immediate.X_add_symbol = dot();
 396                     immediate.X_op = O_symbol;
 397                   }
 398                   op->type = A_DISP_PC;
 399                 }
 400               else
 401                 {
 402                   as_bad ("syntax error in @(disp,[Rn, gbr, pc])");
 403                 }
 404             }
 405           else
 406             {
 407               as_bad ("syntax error in @(disp,[Rn, gbr, pc])");
 408             }
 409         }
 410       src += len;
 411       if (src[0] != ')')
 412         as_bad ("expecting )");
 413       else
 414         src++;
 415     }
 416   else
 417     {
 418       src += parse_reg (src, &mode, &(op->reg));
 419       if (mode != A_REG_N)
 420         {
 421           as_bad ("illegal register after @");
 422         }
 423       if (src[0] == '+')
 424         {
 425           op->type = A_INC_N;
 426           src++;
 427         }
 428       else
 429         {
 430           op->type = A_IND_N;
 431         }
 432     }
 433   return src;
 434 }
 435
 436 static void
 437 get_operand (ptr, op)
 438      char **ptr;
 439      sh_operand_info *op;
 440 {
 441   char *src = *ptr;
 442   int mode = -1;
 443   unsigned int len;
 444
 445   if (src[0] == '#')
 446     {
 447       src++;
 448       *ptr = parse_exp (src);
 449       op->type = A_IMM;
 450       return;
 451     }
 452
 453   else if (src[0] == '@')
 454     {
 455       *ptr = parse_at (src, op);
 456       return;
 457     }
 458   len = parse_reg (src, &mode, &(op->reg));
 459   if (len)
 460     {
 461       *ptr = src + len;
 462       op->type = mode;
 463       return;
 464     }
 465   else
 466     {
 467       /* Not a reg, the only thing left is a displacement */
 468       *ptr = parse_exp (src);
 469       op->type = A_DISP_PC;
 470       return;
 471     }
 472 }
 473
 474 static
 475 char *
 476 get_operands (info, args, operand)
 477      sh_opcode_info *info;
 478      char *args;
 479      sh_operand_info *operand;
 480
 481 {
 482   char *ptr = args;
 483   if (info->arg[0])
 484     {
 485       ptr++;
 486
 487       get_operand (&ptr, operand + 0);
 488       if (info->arg[1])
 489         {
 490           if (*ptr == ',')
 491             {
 492               ptr++;
 493             }
 494           get_operand (&ptr, operand + 1);
 495         }
 496       else
 497         {
 498           operand[1].type = 0;
 499         }
 500     }
 501   else
 502     {
 503       operand[0].type = 0;
 504       operand[1].type = 0;
 505     }
 506   return ptr;
 507 }
 508
 509 /* Passed a pointer to a list of opcodes which use different
 510    addressing modes, return the opcode which matches the opcodes
 511    provided
 512  */
 513
 514 static
 515 sh_opcode_info *
 516 get_specific (opcode, operands)
 517      sh_opcode_info *opcode;
 518      sh_operand_info *operands;
 519 {
 520   sh_opcode_info *this_try = opcode;
 521   char *name = opcode->name;
 522   int arg_to_test = 0;
 523   int n = 0;
 524   while (opcode->name)
 525     {
 526       this_try = opcode++;
 527       if (this_try->name != name)
 528         {
 529           /* We've looked so far down the table that we've run out of
 530              opcodes with the same name */
 531           return 0;
 532         }
 533       /* look at both operands needed by the opcodes and provided by
 534          the user - since an arg test will often fail on the same arg
 535          again and again, we'll try and test the last failing arg the
 536          first on each opcode try */
 537
 538       for (n = 0; this_try->arg[n]; n++)
 539         {
 540           sh_operand_info *user = operands + arg_to_test;
 541           sh_arg_type arg = this_try->arg[arg_to_test];
 542           switch (arg)
 543             {
 544             case A_IMM:
 545             case A_BDISP12:
 546             case A_BDISP8:
 547             case A_DISP_GBR:
 548             case A_DISP_PC:
 549             case A_MACH:
 550             case A_PR:
 551             case A_MACL:
 552               if (user->type != arg)
 553                 goto fail;
 554               break;
 555             case A_R0:
 556               /* opcode needs r0 */
 557               if (user->type != A_REG_N || user->reg != 0)
 558                 goto fail;
 559               break;
 560             case A_R0_GBR:
 561               if (user->type != A_R0_GBR || user->reg != 0)
 562                 goto fail;
 563               break;
 564
 565             case A_REG_N:
 566             case A_INC_N:
 567             case A_DEC_N:
 568             case A_IND_N:
 569             case A_IND_R0_REG_N:
 570             case A_DISP_REG_N:
 571               /* Opcode needs rn */
 572               if (user->type != arg)
 573                 goto fail;
 574               reg_n = user->reg;
 575               break;
 576             case A_GBR:
 577             case A_SR:
 578             case A_VBR:
 579               if (user->type != arg)
 580                 goto fail;
 581               break;
 582
 583             case A_REG_M:
 584             case A_INC_M:
 585             case A_DEC_M:
 586             case A_IND_M:
 587             case A_IND_R0_REG_M:
 588             case A_DISP_REG_M:
 589               /* Opcode needs rn */
 590               if (user->type != arg - A_REG_M + A_REG_N)
 591                 goto fail;
 592               reg_m = user->reg;
 593               break;
 594             default:
 595               printf ("unhandled %d\n", arg);
 596               goto fail;
 597             }
 598           /* If we did 0, test 1 next, else 0 */
 599           arg_to_test = 1 - arg_to_test;
 600         }
 601       return this_try;
 602     fail:;
 603     }
 604
 605   return 0;
 606 }
 607
 608 int
 609 check (operand, low, high)
 610      expressionS *operand;
 611      int low;
 612      int high;
 613 {
 614   if (operand->X_op != O_constant
 615       || operand->X_add_number < low
 616       || operand->X_add_number > high)
 617     {
 618       as_bad ("operand must be absolute in range %d..%d", low, high);
 619     }
 620   return operand->X_add_number;
 621 }
 622
 623
 624 static void
 625 insert (where, how, pcrel)
 626      char *where;
 627      int how;
 628      int pcrel;
 629 {
 630   fix_new_exp (frag_now,
 631                where - frag_now->fr_literal,
 632                4,
 633                &immediate,
 634                pcrel,
 635                how);
 636
 637 }
 638
 639 static void
 640 build_relax (opcode)
 641      sh_opcode_info *opcode;
 642 {
 643   int len;
 644   char *p;
 645   if (opcode->arg[0] == A_BDISP8)
 646     {
 647       p = frag_var (rs_machine_dependent,
 648                     md_relax_table[C (COND_JUMP, COND32)].rlx_length,
 649                     len = md_relax_table[C (COND_JUMP, COND8)].rlx_length,
 650                     C (COND_JUMP, 0),
 651                     immediate.X_add_symbol,
 652                     immediate.X_add_number,
 653                     0);
 654       p[0] = (opcode->nibbles[0] << 4) | (opcode->nibbles[1]);
 655     }
 656   else if (opcode->arg[0] == A_BDISP12)
 657     {
 658       p = frag_var (rs_machine_dependent,
 659                     md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length,
 660                  len = md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length,
 661                     C (UNCOND_JUMP, 0),
 662                     immediate.X_add_symbol,
 663                     immediate.X_add_number,
 664                     0);
 665       p[0] = (opcode->nibbles[0] << 4);
 666     }
 667
 668 }
 669
 670 /* Now we know what sort of opcodes it is, lets build the bytes -
 671  */
 672 static void
 673 build_Mytes (opcode, operand)
 674      sh_opcode_info *opcode;
 675      sh_operand_info *operand;
 676
 677 {
 678   int index;
 679   char nbuf[4];
 680   char *output = frag_more (2);
 681
 682   nbuf[0] = 0;
 683   nbuf[1] = 0;
 684   nbuf[2] = 0;
 685   nbuf[3] = 0;
 686
 687   for (index = 0; index < 4; index++)
 688     {
 689       sh_nibble_type i = opcode->nibbles[index];
 690       if (i < 16)
 691         {
 692           nbuf[index] = i;
 693         }
 694       else
 695         {
 696           switch (i)
 697             {
 698             case REG_N:
 699               nbuf[index] = reg_n;
 700               break;
 701             case REG_M:
 702               nbuf[index] = reg_m;
 703               break;
 704             case DISP_4:
 705               insert (output + 1, R_SH_IMM4, 0);
 706               break;
 707             case IMM_4BY4:
 708               insert (output + 1, R_SH_IMM4BY4, 0);
 709               break;
 710             case IMM_4BY2:
 711               insert (output + 1, R_SH_IMM4BY2, 0);
 712               break;
 713             case IMM_4:
 714               insert (output + 1, R_SH_IMM4, 0);
 715               break;
 716             case IMM_8BY4:
 717               insert (output + 1, R_SH_IMM8BY4, 0);
 718               break;
 719             case IMM_8BY2:
 720               insert (output + 1, R_SH_IMM8BY2, 0);
 721               break;
 722             case IMM_8:
 723               insert (output + 1, R_SH_IMM8, 0);
 724               break;
 725             case PCRELIMM_8BY4:
 726               insert (output + 1, R_SH_PCRELIMM8BY4, 1);
 727               break;
 728             case PCRELIMM_8BY2:
 729               insert (output + 1, R_SH_PCRELIMM8BY2, 1);
 730               break;
 731             default:
 732               printf ("failed for %d\n", i);
 733             }
 734         }
 735     }
 736   output[0] = (nbuf[0] << 4) | (nbuf[1]);
 737   output[1] = (nbuf[2] << 4) | (nbuf[3]);
 738 }
 739
 740 /* This is the guts of the machine-dependent assembler.  STR points to a
 741    machine dependent instruction.  This function is supposed to emit
 742    the frags/bytes it assembles to.
 743  */
 744
 745 void
 746 md_assemble (str)
 747      char *str;
 748 {
 749   unsigned char *op_start;
 750   unsigned char *op_end;
 751   sh_operand_info operand[2];
 752   sh_opcode_info *opcode;
 753   char name[20];
 754   int nlen = 0;
 755   char *p;
 756   /* Drop leading whitespace */
 757   while (*str == ' ')
 758     str++;
 759
 760   /* find the op code end */
 761   for (op_start = op_end = (unsigned char *) (str);
 762        *op_end
 763        && nlen < 20
 764        && !is_end_of_line[*op_end] && *op_end != ' ';
 765        op_end++)
 766     {
 767       name[nlen] = op_start[nlen];
 768       nlen++;
 769     }
 770   name[nlen] = 0;
 771
 772   if (nlen == 0)
 773     {
 774       as_bad ("can't find opcode ");
 775     }
 776
 777   opcode = (sh_opcode_info *) hash_find (opcode_hash_control, name);
 778
 779   if (opcode == NULL)
 780     {
 781       as_bad ("unknown opcode");
 782       return;
 783     }
 784
 785   if (opcode->arg[0] == A_BDISP12
 786       || opcode->arg[0] == A_BDISP8)
 787     {
 788       parse_exp (op_end + 1);
 789       build_relax (opcode);
 790     }
 791   else
 792     {
 793       if (opcode->arg[0] != A_END)
 794         {
 795           get_operands (opcode, op_end, operand);
 796         }
 797       opcode = get_specific (opcode, operand);
 798
 799       if (opcode == 0)
 800         {
 801           /* Couldn't find an opcode which matched the operands */
 802           char *where = frag_more (2);
 803
 804           where[0] = 0x0;
 805           where[1] = 0x0;
 806           as_bad ("invalid operands for opcode");
 807           return;
 808         }
 809
 810       build_Mytes (opcode, operand);
 811     }
 812
 813 }
 814
 815 void
 816 DEFUN (tc_crawl_symbol_chain, (headers),
 817        object_headers * headers)
 818 {
 819   printf ("call to tc_crawl_symbol_chain \n");
 820 }
 821
 822 symbolS *
 823 DEFUN (md_undefined_symbol, (name),
 824        char *name)
 825 {
 826   return 0;
 827 }
 828
 829 void
 830 DEFUN (tc_headers_hook, (headers),
 831        object_headers * headers)
 832 {
 833   printf ("call to tc_headers_hook \n");
 834 }
 835
 836 /* Various routines to kill one day */
 837 /* Equal to MAX_PRECISION in atof-ieee.c */
 838 #define MAX_LITTLENUMS 6
 839
 840 /* Turn a string in input_line_pointer into a floating point constant of type
 841    type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
 842    emitted is stored in *sizeP .  An error message is returned, or NULL on OK.
 843  */
 844 char *
 845 md_atof (type, litP, sizeP)
 846      char type;
 847      char *litP;
 848      int *sizeP;
 849 {
 850   int prec;
 851   LITTLENUM_TYPE words[MAX_LITTLENUMS];
 852   LITTLENUM_TYPE *wordP;
 853   char *t;
 854   char *atof_ieee ();
 855
 856   switch (type)
 857     {
 858     case 'f':
 859     case 'F':
 860     case 's':
 861     case 'S':
 862       prec = 2;
 863       break;
 864
 865     case 'd':
 866     case 'D':
 867     case 'r':
 868     case 'R':
 869       prec = 4;
 870       break;
 871
 872     case 'x':
 873     case 'X':
 874       prec = 6;
 875       break;
 876
 877     case 'p':
 878     case 'P':
 879       prec = 6;
 880       break;
 881
 882     default:
 883       *sizeP = 0;
 884       return "Bad call to MD_NTOF()";
 885     }
 886   t = atof_ieee (input_line_pointer, type, words);
 887   if (t)
 888     input_line_pointer = t;
 889
 890   *sizeP = prec * sizeof (LITTLENUM_TYPE);
 891   for (wordP = words; prec--;)
 892     {
 893       md_number_to_chars (litP, (long) (*wordP++), sizeof (LITTLENUM_TYPE));
 894       litP += sizeof (LITTLENUM_TYPE);
 895     }
 896   return 0;
 897 }
 898 \f
 899 CONST char *md_shortopts = "";
 900 struct option md_longopts[] = {
 901 #define OPTION_RELAX (OPTION_MD_BASE)
 902   {"relax", no_argument, NULL, OPTION_RELAX},
 903   {NULL, no_argument, NULL, 0}
 904 };
 905 size_t md_longopts_size = sizeof(md_longopts);
 906
 907 int
 908 md_parse_option (c, arg)
 909      int c;
 910      char *arg;
 911 {
 912   switch (c)
 913     {
 914     case OPTION_RELAX:
 915       relax = 1;
 916       break;
 917
 918     default:
 919       return 0;
 920     }
 921
 922   return 1;
 923 }
 924
 925 void
 926 md_show_usage (stream)
 927      FILE *stream;
 928 {
 929   fprintf(stream, "\
 930 SH options:\n\
 931 -relax                  alter jump instructions for long displacements\n");
 932 }
 933 \f
 934 int md_short_jump_size;
 935
 936 void
 937 tc_Nout_fix_to_chars ()
 938 {
 939   printf ("call to tc_Nout_fix_to_chars \n");
 940   abort ();
 941 }
 942
 943 void
 944 md_create_short_jump (ptr, from_Nddr, to_Nddr, frag, to_symbol)
 945      char *ptr;
 946      addressT from_Nddr;
 947      addressT to_Nddr;
 948      fragS *frag;
 949      symbolS *to_symbol;
 950 {
 951   as_fatal ("failed sanity check.");
 952 }
 953
 954 void
 955 md_create_long_jump (ptr, from_Nddr, to_Nddr, frag, to_symbol)
 956      char *ptr;
 957      addressT from_Nddr, to_Nddr;
 958      fragS *frag;
 959      symbolS *to_symbol;
 960 {
 961   as_fatal ("failed sanity check.");
 962 }
 963
 964 /*
 965    called after relaxing, change the frags so they know how big they are
 966  */
 967 void
 968 md_convert_frag (headers, fragP)
 969      object_headers *headers;
 970      fragS *fragP;
 971
 972 {
 973   unsigned char *buffer = (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
 974   int donerelax = 0;
 975   int targ_addr = ((fragP->fr_symbol ? S_GET_VALUE (fragP->fr_symbol) : 0) + fragP->fr_offset);
 976   switch (fragP->fr_subtype)
 977     {
 978     case C (COND_JUMP, COND8):
 979       {
 980         /* Get the address of the end of the instruction */
 981         int next_inst = fragP->fr_fix + fragP->fr_address + 2;
 982
 983         int disp = targ_addr - next_inst - 2;
 984         disp /= 2;
 985
 986         md_number_to_chars (buffer + 1, disp & 0xff, 1);
 987         fragP->fr_fix += 2;
 988         fragP->fr_var = 0;
 989       }
 990       break;
 991
 992     case C (UNCOND_JUMP, UNCOND12):
 993       {
 994         /* Get the address of the end of the instruction */
 995         int next_inst = fragP->fr_fix + fragP->fr_address + 2;
 996
 997         int t;
 998         int disp = targ_addr - next_inst - 2;
 999
1000         disp /= 2;
1001         t = buffer[0] & 0xf0;
1002         md_number_to_chars (buffer, disp & 0xfff, 2);
1003         buffer[0] = (buffer[0] & 0xf) | t;
1004         fragP->fr_fix += 2;
1005         fragP->fr_var = 0;
1006       }
1007       break;
1008
1009     case C (UNCOND_JUMP, UNCOND32):
1010     case C (UNCOND_JUMP, UNDEF_WORD_DISP):
1011       {
1012         /* A jump wont fit in 12 bits, make code which looks like
1013            bra foo
1014            mov.w @(0, PC), r14
1015            .long disp
1016            foo: bra @r14
1017          */
1018
1019         int next_inst =
1020         fragP->fr_fix + fragP->fr_address + UNCOND32_LENGTH;
1021
1022         int disp = targ_addr - next_inst;
1023         int t = buffer[0] & 0x10;
1024
1025         disp /= 2;
1026
1027         buffer[0] = 0xa0;       /* branch over move and disp */
1028         buffer[1] = 3;
1029         buffer[2] = 0xd0 | JREG;        /* Build mov insn */
1030         buffer[3] = 0x00;
1031
1032         buffer[4] = 0;          /* space for 32 bit jump disp */
1033         buffer[5] = 0;
1034         buffer[6] = 0;
1035         buffer[7] = 0;
1036
1037         buffer[10] = 0x40 | JREG;       /* Build jmp @JREG */
1038         buffer[11] = t ? 0xb : 0x2b;
1039
1040         buffer[12] = 0x20;      /* build nop */
1041         buffer[13] = 0x0b;
1042
1043         /* Make reloc for the long disp */
1044         fix_new (fragP,
1045                  fragP->fr_fix + 4,
1046                  4,
1047                  fragP->fr_symbol,
1048                  fragP->fr_offset,
1049                  0,
1050                  R_SH_IMM32);
1051         fragP->fr_fix += UNCOND32_LENGTH;
1052         fragP->fr_var = 0;
1053         donerelax = 1;
1054
1055       }
1056       break;
1057
1058     case C (COND_JUMP, COND12):
1059       {
1060         /* A bcond won't fit, so turn it into a b!cond; bra disp; nop */
1061         int next_inst =
1062         fragP->fr_fix + fragP->fr_address + 6;
1063
1064         int disp = targ_addr - next_inst;
1065         disp /= 2;
1066         md_number_to_chars (buffer + 2, disp & 0xfff, 2);
1067         buffer[0] ^= 0x2;       /* Toggle T/F bit */
1068         buffer[1] = 1;          /* branch over jump and nop */
1069         buffer[2] = (buffer[2] & 0xf) | 0xa0;   /* Build jump insn */
1070         buffer[4] = 0x20;       /* Build nop */
1071         buffer[5] = 0x0b;
1072         fragP->fr_fix += 6;
1073         fragP->fr_var = 0;
1074         donerelax = 1;
1075       }
1076       break;
1077
1078     case C (COND_JUMP, COND32):
1079     case C (COND_JUMP, UNDEF_WORD_DISP):
1080       {
1081         /* A bcond won't fit and it won't go into a 12 bit
1082            displacement either, the code sequence looks like:
1083            b!cond foop
1084            mov.w @(n, PC), r14
1085            jmp  @r14
1086            nop
1087            .long where
1088            foop:
1089          */
1090
1091         int next_inst =
1092         fragP->fr_fix + fragP->fr_address + COND32_LENGTH;
1093
1094         int disp = targ_addr - next_inst;
1095         disp /= 2;
1096
1097         buffer[0] ^= 0x2;       /* Toggle T/F bit */
1098 #define JREG 14
1099         buffer[1] = 5;          /* branch over mov, jump, nop and ptr */
1100         buffer[2] = 0xd0 | JREG;        /* Build mov insn */
1101         buffer[3] = 0x2;
1102         buffer[4] = 0x40 | JREG;        /* Build jmp @JREG */
1103         buffer[5] = 0x0b;
1104         buffer[6] = 0x20;       /* build nop */
1105         buffer[7] = 0x0b;
1106         buffer[8] = 0;          /* space for 32 bit jump disp */
1107         buffer[9] = 0;
1108         buffer[10] = 0;
1109         buffer[11] = 0;
1110         buffer[12] = 0;
1111         buffer[13] = 0;
1112         /* Make reloc for the long disp */
1113         fix_new (fragP,
1114                  fragP->fr_fix + 8,
1115                  4,
1116                  fragP->fr_symbol,
1117                  fragP->fr_offset,
1118                  0,
1119                  R_SH_IMM32);
1120         fragP->fr_fix += COND32_LENGTH;
1121         fragP->fr_var = 0;
1122         donerelax = 1;
1123       }
1124       break;
1125
1126     default:
1127       abort ();
1128     }
1129
1130   if (donerelax && !relax)
1131     {
1132       as_warn ("Offset doesn't fit at 0x%x, trying to get to %s+0x%x",
1133                fragP->fr_address,
1134                fragP->fr_symbol  ?    S_GET_NAME(fragP->fr_symbol): "",
1135                targ_addr);
1136     }
1137
1138 }
1139
1140 valueT
1141 DEFUN (md_section_align, (seg, size),
1142        segT seg AND
1143        valueT size)
1144 {
1145   return ((size + (1 << section_alignment[(int) seg]) - 1)
1146           & (-1 << section_alignment[(int) seg]));
1147
1148 }
1149
1150 void
1151 md_apply_fix (fixP, val)
1152      fixS *fixP;
1153      long val;
1154 {
1155   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
1156   int addr = fixP->fx_frag->fr_address + fixP->fx_where;
1157   if (fixP->fx_r_type == 0)
1158     {
1159       if (fixP->fx_size == 2)
1160         fixP->fx_r_type = R_SH_IMM16;
1161       else
1162         fixP->fx_r_type = R_SH_IMM32;
1163     }
1164
1165   switch (fixP->fx_r_type)
1166     {
1167
1168     case R_SH_IMM4:
1169       *buf = (*buf & 0xf0) | (val & 0xf);
1170       break;
1171
1172     case R_SH_IMM4BY2:
1173       *buf = (*buf & 0xf0) | ((val >> 1) & 0xf);
1174       break;
1175
1176     case R_SH_IMM4BY4:
1177       *buf = (*buf & 0xf0) | ((val >> 2) & 0xf);
1178       break;
1179
1180     case R_SH_IMM8BY2:
1181       *buf = val >> 1;
1182       break;
1183
1184     case R_SH_IMM8BY4:
1185       *buf = val >> 2;
1186       break;
1187
1188     case R_SH_IMM8:
1189       *buf++ = val;
1190       break;
1191
1192     case R_SH_PCRELIMM8BY4:
1193       addr &= ~1;
1194 #if 0
1195       if (val & 0x3)
1196         as_warn ("non aligned displacement at %x\n", addr);
1197 #endif
1198       /*      val -= (addr + 4); */
1199       val += 3;
1200       val /= 4;
1201       if (val & ~0xff)
1202         as_warn ("pcrel too far at %x\n", addr);
1203
1204       *buf = val;
1205       break;
1206
1207     case R_SH_PCRELIMM8BY2:
1208       addr &= ~1;
1209       if (val & 0x1)
1210         as_bad ("odd displacement at %x\n", addr);
1211       /*      val -= (addr + 4); */
1212       val++;
1213       val /= 2;
1214       if (val & ~0xff)
1215         as_warn ("pcrel too far at %x\n", addr);
1216       *buf = val;
1217       break;
1218
1219     case R_SH_IMM32:
1220       *buf++ = val >> 24;
1221       *buf++ = val >> 16;
1222       *buf++ = val >> 8;
1223       *buf++ = val >> 0;
1224       break;
1225
1226     case R_SH_IMM16:
1227       *buf++ = val >> 8;
1228       *buf++ = val >> 0;
1229       break;
1230
1231     default:
1232       abort ();
1233     }
1234 }
1235
1236 void
1237 DEFUN (md_operand, (expressionP), expressionS * expressionP)
1238 {
1239 }
1240
1241 int md_long_jump_size;
1242
1243 /*
1244    called just before address relaxation, return the length
1245    by which a fragment must grow to reach it's destination
1246  */
1247 int
1248 md_estimate_size_before_relax (fragP, segment_type)
1249      register fragS *fragP;
1250      register segT segment_type;
1251 {
1252   switch (fragP->fr_subtype)
1253     {
1254     case C (UNCOND_JUMP, UNDEF_DISP):
1255       /* used to be a branch to somewhere which was unknown */
1256       if (!fragP->fr_symbol)
1257         {
1258           fragP->fr_subtype = C (UNCOND_JUMP, UNCOND12);
1259           fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length;
1260         }
1261       else if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
1262         {
1263           fragP->fr_subtype = C (UNCOND_JUMP, UNCOND12);
1264           fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length;
1265         }
1266       else
1267         {
1268           fragP->fr_subtype = C (UNCOND_JUMP, UNDEF_WORD_DISP);
1269           fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length;
1270           return md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length;
1271         }
1272       break;
1273
1274     default:
1275       abort ();
1276     case C (COND_JUMP, UNDEF_DISP):
1277       /* used to be a branch to somewhere which was unknown */
1278       if (fragP->fr_symbol
1279           && S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
1280         {
1281           /* Got a symbol and it's defined in this segment, become byte
1282              sized - maybe it will fix up */
1283           fragP->fr_subtype = C (COND_JUMP, COND8);
1284           fragP->fr_var = md_relax_table[C (COND_JUMP, COND8)].rlx_length;
1285         }
1286       else if (fragP->fr_symbol)
1287         {
1288           /* Its got a segment, but its not ours, so it will always be long */
1289           fragP->fr_subtype = C (COND_JUMP, UNDEF_WORD_DISP);
1290           fragP->fr_var = md_relax_table[C (COND_JUMP, COND32)].rlx_length;
1291           return md_relax_table[C (COND_JUMP, COND32)].rlx_length;
1292         }
1293       else
1294         {
1295           /* We know the abs value */
1296           fragP->fr_subtype = C (COND_JUMP, COND8);
1297           fragP->fr_var = md_relax_table[C (COND_JUMP, COND8)].rlx_length;
1298         }
1299
1300       break;
1301     }
1302   return fragP->fr_var;
1303 }
1304
1305 /* Put number into target byte order */
1306
1307 void
1308 md_number_to_chars (ptr, use, nbytes)
1309      char *ptr;
1310      valueT use;
1311      int nbytes;
1312 {
1313   number_to_chars_bigendian (ptr, use, nbytes);
1314 }
1315
1316 long
1317 md_pcrel_from (fixP)
1318      fixS *fixP;
1319 {
1320   int gap = fixP->fx_size + fixP->fx_where +  fixP->fx_frag->fr_address - 1 ;
1321   return gap;
1322 }
1323
1324 short
1325 tc_coff_fix2rtype (fix_ptr)
1326      fixS *fix_ptr;
1327 {
1328   return fix_ptr->fx_r_type;
1329 }
1330
1331 void
1332 tc_reloc_mangle (fix_ptr, intr, base)
1333      fixS *fix_ptr;
1334      struct internal_reloc *intr;
1335      bfd_vma base;
1336
1337 {
1338   symbolS *symbol_ptr;
1339
1340   symbol_ptr = fix_ptr->fx_addsy;
1341
1342   /* If this relocation is attached to a symbol then it's ok
1343      to output it */
1344   if (fix_ptr->fx_r_type == RELOC_32)
1345     {
1346       /* cons likes to create reloc32's whatever the size of the reloc..
1347        */
1348       switch (fix_ptr->fx_size)
1349         {
1350         case 2:
1351           intr->r_type = R_IMM16;
1352           break;
1353         case 1:
1354           intr->r_type = R_IMM8;
1355           break;
1356         default:
1357           abort ();
1358         }
1359     }
1360   else
1361     {
1362       intr->r_type = fix_ptr->fx_r_type;
1363     }
1364
1365   intr->r_vaddr = fix_ptr->fx_frag->fr_address + fix_ptr->fx_where + base;
1366   intr->r_offset = fix_ptr->fx_offset;
1367
1368   /* Turn the segment of the symbol into an offset.  */
1369   if (symbol_ptr)
1370     {
1371       symbolS *dot;
1372
1373       dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
1374       if (dot)
1375         {
1376           intr->r_offset += S_GET_VALUE (symbol_ptr);
1377           intr->r_symndx = dot->sy_number;
1378         }
1379       else
1380         {
1381           intr->r_symndx = symbol_ptr->sy_number;
1382         }
1383     }
1384   else
1385     {
1386       intr->r_symndx = -1;
1387     }
1388 }
1389
1390 int
1391 tc_coff_sizemachdep (frag)
1392      fragS *frag;
1393 {
1394   return md_relax_table[frag->fr_subtype].rlx_length;
1395 }