gas/config/tc-sparc.c

   1 /* tc-sparc.c -- Assemble for the SPARC
   2    Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
   3
   4    This file is part of GAS, the GNU Assembler.
   5
   6    GAS is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    GAS is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GAS; see the file COPYING.  If not, write to
  18    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  19
  20 #define cypress 1234
  21
  22 #include <stdio.h>
  23 #include <ctype.h>
  24
  25 #include "as.h"
  26
  27 /* careful, this file includes data *declarations* */
  28 #include "opcode/sparc.h"
  29
  30 void md_begin();
  31 void md_end();
  32 void md_number_to_chars();
  33 void md_assemble();
  34 char *md_atof();
  35 void md_convert_frag();
  36 void md_create_short_jump();
  37 void md_create_long_jump();
  38 int md_estimate_size_before_relax();
  39 void md_ri_to_chars();
  40 symbolS *md_undefined_symbol();
  41 static void sparc_ip();
  42
  43 static enum sparc_architecture current_architecture = v6;
  44 static int architecture_requested = 0;
  45 static int warn_on_bump = 0;
  46
  47 const relax_typeS md_relax_table[] = {
  48         0 };
  49
  50 /* handle of the OPCODE hash table */
  51 static struct hash_control *op_hash = NULL;
  52
  53 static void s_seg(), s_proc(), s_data1(), s_reserve(), s_common();
  54 extern void s_globl(), s_long(), s_short(), s_space(), cons();
  55 extern void s_align_bytes(), s_ignore();
  56
  57 const pseudo_typeS md_pseudo_table[] = {
  58         { "align",      s_align_bytes,  0       },    /* Defaulting is invalid (0) */
  59         { "common",     s_common,       0       },
  60         { "global",     s_globl,        0       },
  61         { "half",       cons,           2       },
  62         { "optim",      s_ignore,       0       },
  63         { "proc",       s_proc,         0       },
  64         { "reserve",    s_reserve,      0       },
  65         { "seg",        s_seg,          0       },
  66         { "skip",       s_space,        0       },
  67         { "word",       cons,           4       },
  68         { NULL, 0,              0       },
  69 };
  70
  71 const int md_short_jump_size = 4;
  72 const int md_long_jump_size = 4;
  73 const int md_reloc_size = 12;                   /* Size of relocation record */
  74
  75 /* This array holds the chars that always start a comment.  If the
  76    pre-processor is disabled, these aren't very useful */
  77 const char comment_chars[] = "!";       /* JF removed '|' from comment_chars */
  78
  79 /* This array holds the chars that only start a comment at the beginning of
  80    a line.  If the line seems to have the form '# 123 filename'
  81    .line and .file directives will appear in the pre-processed output */
  82 /* Note that input_file.c hand checks for '#' at the beginning of the
  83    first line of the input file.  This is because the compiler outputs
  84    #NO_APP at the beginning of its output. */
  85 /* Also note that comments started like this one will always
  86    work if '/' isn't otherwise defined. */
  87 const char line_comment_chars[] = "#";
  88
  89 /* Chars that can be used to separate mant from exp in floating point nums */
  90 const char EXP_CHARS[] = "eE";
  91
  92 /* Chars that mean this number is a floating point constant */
  93 /* As in 0f12.456 */
  94 /* or    0d1.2345e12 */
  95 const char FLT_CHARS[] = "rRsSfFdDxXpP";
  96
  97 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
  98    changed in read.c .  Ideally it shouldn't have to know about it at all,
  99    but nothing is ideal around here.
 100    */
 101
 102 static unsigned char octal[256];
 103 #define isoctal(c)  octal[c]
 104     static unsigned char toHex[256];
 105
 106 struct sparc_it {
 107         char *error;
 108         unsigned long opcode;
 109         struct nlist *nlistp;
 110         expressionS exp;
 111         int pcrel;
 112         enum reloc_type reloc;
 113 } the_insn, set_insn;
 114
 115 #if __STDC__ == 1
 116 #if 0
 117 static void print_insn(struct sparc_it *insn);
 118 #endif
 119 static int getExpression(char *str);
 120 #else /* not __STDC__ */
 121 #if 0
 122 static void print_insn();
 123 #endif
 124 static int getExpression();
 125 #endif /* not __STDC__ */
 126
 127 static char *expr_end;
 128 static int special_case;
 129
 130 /*
 131  * Instructions that require wierd handling because they're longer than
 132  * 4 bytes.
 133  */
 134 #define SPECIAL_CASE_SET        1
 135 #define SPECIAL_CASE_FDIV       2
 136
 137 /*
 138  * sort of like s_lcomm
 139  *
 140  */
 141 static int max_alignment = 15;
 142
 143 static void s_reserve() {
 144         char *name;
 145         char *p;
 146         char c;
 147         int align;
 148         int size;
 149         int temp;
 150         symbolS *symbolP;
 151
 152         name = input_line_pointer;
 153         c = get_symbol_end();
 154         p = input_line_pointer;
 155         *p = c;
 156         SKIP_WHITESPACE();
 157
 158         if (*input_line_pointer != ',') {
 159                 as_bad("Expected comma after name");
 160                 ignore_rest_of_line();
 161                 return;
 162         }
 163
 164         ++input_line_pointer;
 165
 166         if ((size = get_absolute_expression()) < 0) {
 167                 as_bad("BSS length (%d.) <0! Ignored.", size);
 168                 ignore_rest_of_line();
 169                 return;
 170         } /* bad length */
 171
 172         *p = 0;
 173         symbolP = symbol_find_or_make(name);
 174         *p = c;
 175
 176         if (strncmp(input_line_pointer, ",\"bss\"", 6) != 0) {
 177                 as_bad("bad .reserve segment: `%s'", input_line_pointer);
 178                 return;
 179         } /* if not bss */
 180
 181         input_line_pointer += 6;
 182         SKIP_WHITESPACE();
 183
 184         if (*input_line_pointer == ',') {
 185                 ++input_line_pointer;
 186
 187                 SKIP_WHITESPACE();
 188                 if (*input_line_pointer == '\n') {
 189                         as_bad("Missing alignment");
 190                         return;
 191                 }
 192
 193                 align = get_absolute_expression();
 194                 if (align > max_alignment){
 195                         align = max_alignment;
 196                         as_warn("Alignment too large: %d. assumed.", align);
 197                 } else if (align < 0) {
 198                         align = 0;
 199                         as_warn("Alignment negative. 0 assumed.");
 200                 }
 201 #ifdef MANY_SEGMENTS
 202 #define SEG_BSS SEG_E2
 203                 record_alignment(SEG_E2, align);
 204 #else
 205                 record_alignment(SEG_BSS, align);
 206 #endif
 207
 208                 /* convert to a power of 2 alignment */
 209                 for (temp = 0; (align & 1) == 0; align >>= 1, ++temp) ;;
 210
 211                 if (align != 1) {
 212                         as_bad("Alignment not a power of 2");
 213                         ignore_rest_of_line();
 214                         return;
 215                 } /* not a power of two */
 216
 217                 align = temp;
 218
 219                 /* Align */
 220                 align = ~((~0) << align);       /* Convert to a mask */
 221                 local_bss_counter = (local_bss_counter + align) & (~align);
 222         } /* if has optional alignment */
 223
 224         if (S_GET_OTHER(symbolP) == 0
 225             && S_GET_DESC(symbolP) == 0
 226             && ((S_GET_SEGMENT(symbolP) == SEG_BSS
 227                  && S_GET_VALUE(symbolP) == local_bss_counter)
 228                 || !S_IS_DEFINED(symbolP))) {
 229                 S_SET_VALUE(symbolP, local_bss_counter);
 230                 S_SET_SEGMENT(symbolP, SEG_BSS);
 231                 symbolP->sy_frag  = &bss_address_frag;
 232                 local_bss_counter += size;
 233         } else {
 234                 as_warn("Ignoring attempt to re-define symbol from %d. to %d.",
 235                         S_GET_VALUE(symbolP), local_bss_counter);
 236         } /* if not redefining */
 237
 238         demand_empty_rest_of_line();
 239         return;
 240 } /* s_reserve() */
 241
 242 static void s_common() {
 243         register char *name;
 244         register char c;
 245         register char *p;
 246         register int temp;
 247         register symbolS *      symbolP;
 248
 249         name = input_line_pointer;
 250         c = get_symbol_end();
 251         /* just after name is now '\0' */
 252         p = input_line_pointer;
 253         *p = c;
 254         SKIP_WHITESPACE();
 255         if (* input_line_pointer != ',') {
 256                 as_bad("Expected comma after symbol-name");
 257                 ignore_rest_of_line();
 258                 return;
 259         }
 260         input_line_pointer ++; /* skip ',' */
 261         if ((temp = get_absolute_expression ()) < 0) {
 262                 as_bad(".COMMon length (%d.) <0! Ignored.", temp);
 263                 ignore_rest_of_line();
 264                 return;
 265         }
 266         *p = 0;
 267         symbolP = symbol_find_or_make(name);
 268         *p = c;
 269         if (S_IS_DEFINED(symbolP)) {
 270                 as_bad("Ignoring attempt to re-define symbol");
 271                 ignore_rest_of_line();
 272                 return;
 273         }
 274         if (S_GET_VALUE(symbolP) != 0) {
 275                 if (S_GET_VALUE(symbolP) != temp) {
 276                         as_warn("Length of .comm \"%s\" is already %d. Not changed to %d.",
 277                                 S_GET_NAME(symbolP), S_GET_VALUE(symbolP), temp);
 278                 }
 279         } else {
 280                 S_SET_VALUE(symbolP, temp);
 281                 S_SET_EXTERNAL(symbolP);
 282         }
 283         know(symbolP->sy_frag == &zero_address_frag);
 284         if (strncmp(input_line_pointer, ",\"bss\"", 6) != 0
 285             && strncmp(input_line_pointer, ",\"data\"", 7) != 0) {
 286                 p=input_line_pointer;
 287                 while(*p && *p!='\n')
 288                     p++;
 289                 c= *p;
 290                 *p='\0';
 291                 as_bad("bad .common segment: `%s'", input_line_pointer);
 292                 *p=c;
 293                 return;
 294         }
 295         input_line_pointer += 6 + (input_line_pointer[2] == 'd'); /* Skip either */
 296         demand_empty_rest_of_line();
 297         return;
 298 } /* s_common() */
 299
 300 static void s_seg() {
 301
 302         if (strncmp(input_line_pointer, "\"text\"", 6) == 0) {
 303                 input_line_pointer += 6;
 304                 s_text();
 305                 return;
 306         }
 307         if (strncmp(input_line_pointer, "\"data\"", 6) == 0) {
 308                 input_line_pointer += 6;
 309                 s_data();
 310                 return;
 311         }
 312         if (strncmp(input_line_pointer, "\"data1\"", 7) == 0) {
 313                 input_line_pointer += 7;
 314                 s_data1();
 315                 return;
 316         }
 317         if (strncmp(input_line_pointer, "\"bss\"", 5) == 0) {
 318                 input_line_pointer += 5;
 319                 /* We only support 2 segments -- text and data -- for now, so
 320                    things in the "bss segment" will have to go into data for now.
 321                    You can still allocate SEG_BSS stuff with .lcomm or .reserve. */
 322                 subseg_new(SEG_DATA, 255);      /* FIXME-SOMEDAY */
 323                 return;
 324         }
 325         as_bad("Unknown segment type");
 326         demand_empty_rest_of_line();
 327         return;
 328 } /* s_seg() */
 329
 330 static void s_data1() {
 331         subseg_new(SEG_DATA, 1);
 332         demand_empty_rest_of_line();
 333         return;
 334 } /* s_data1() */
 335
 336 static void s_proc() {
 337         extern char is_end_of_line[];
 338
 339         while (!is_end_of_line[*input_line_pointer]) {
 340                 ++input_line_pointer;
 341         }
 342         ++input_line_pointer;
 343         return;
 344 } /* s_proc() */
 345
 346 /* start-sanitize-v9 */
 347 #ifndef NO_V9
 348 struct priv_reg_entry { char *name; int regnum; };
 349 struct priv_reg_entry priv_reg_table[] =
 350 {
 351   { "tpc", 0 },
 352   { "tnpc", 1 },
 353   { "tstate", 2 },
 354   { "tt", 3 },
 355   { "tick", 4 },
 356   { "tba", 5 },
 357   { "pstate", 6 },
 358   { "tl", 7 },
 359   { "pil", 8 },
 360   { "cwp", 9 },
 361   { "cansave", 10 },
 362   { "canrestore", 11 },
 363   { "cleanwin", 12 },
 364   { "otherwin", 13 },
 365   { "wstate", 14},
 366   { "fpq", 15},
 367   { "ver", 31 },
 368   { "", -1 }, /* end marker */
 369 };
 370
 371 static int cmp_reg_entry (p, q)
 372      struct priv_reg_entry *p, *q;
 373 {
 374   return strcmp (q->name, p->name);
 375 }
 376 #endif
 377 /* end-sanitize-v9 */
 378
 379 /* This function is called once, at assembler startup time.  It should
 380    set up all the tables, etc. that the MD part of the assembler will need. */
 381 void md_begin() {
 382         register char *retval = NULL;
 383         int lose = 0;
 384         register unsigned int i = 0;
 385
 386         op_hash = hash_new();
 387         if (op_hash == NULL)
 388             as_fatal("Virtual memory exhausted");
 389
 390         while (i < NUMOPCODES) {
 391                 const char *name = sparc_opcodes[i].name;
 392                 retval = hash_insert(op_hash, name, &sparc_opcodes[i]);
 393                 if(retval != NULL && *retval != '\0') {
 394                         fprintf (stderr, "internal error: can't hash `%s': %s\n",
 395                                  sparc_opcodes[i].name, retval);
 396                         lose = 1;
 397                 }
 398                 do
 399                     {
 400                             if (sparc_opcodes[i].match & sparc_opcodes[i].lose) {
 401                                     fprintf (stderr, "internal error: losing opcode: `%s' \"%s\"\n",
 402                                              sparc_opcodes[i].name, sparc_opcodes[i].args);
 403                                     lose = 1;
 404                             }
 405                             ++i;
 406                     } while (i < NUMOPCODES
 407                              && !strcmp(sparc_opcodes[i].name, name));
 408         }
 409
 410         if (lose)
 411             as_fatal("Broken assembler.  No assembly attempted.");
 412
 413         for (i = '0'; i < '8'; ++i)
 414             octal[i] = 1;
 415         for (i = '0'; i <= '9'; ++i)
 416             toHex[i] = i - '0';
 417         for (i = 'a'; i <= 'f'; ++i)
 418             toHex[i] = i + 10 - 'a';
 419         for (i = 'A'; i <= 'F'; ++i)
 420             toHex[i] = i + 10 - 'A';
 421
 422 /* start-sanitize-v9 */
 423 #ifndef NO_V9
 424         qsort (priv_reg_table, sizeof (priv_reg_table) / sizeof (priv_reg_table[0]),
 425                sizeof (priv_reg_table[0]), cmp_reg_entry);
 426 #endif
 427 /* end-sanitize-v9 */
 428 } /* md_begin() */
 429
 430 void md_end() {
 431         return;
 432 } /* md_end() */
 433
 434 void md_assemble(str)
 435 char *str;
 436 {
 437         char *toP;
 438         int rsd;
 439
 440         know(str);
 441         sparc_ip(str);
 442
 443         /* See if "set" operand is absolute and small; skip sethi if so. */
 444         if (special_case == SPECIAL_CASE_SET && the_insn.exp.X_seg == SEG_ABSOLUTE) {
 445                 if (the_insn.exp.X_add_number >= -(1<<12)
 446                     && the_insn.exp.X_add_number <   (1<<12)) {
 447                         the_insn.opcode = 0x80102000            /* or %g0,imm,... */
 448                             | (the_insn.opcode & 0x3E000000)    /* dest reg */
 449                                 | (the_insn.exp.X_add_number & 0x1FFF); /* imm */
 450                         special_case = 0;               /* No longer special */
 451                         the_insn.reloc = NO_RELOC;      /* No longer relocated */
 452                 }
 453         }
 454
 455         toP = frag_more(4);
 456         /* put out the opcode */
 457         md_number_to_chars(toP, the_insn.opcode, 4);
 458
 459         /* put out the symbol-dependent stuff */
 460         if (the_insn.reloc != NO_RELOC) {
 461                 fix_new(frag_now,                           /* which frag */
 462                         (toP - frag_now->fr_literal), /* where */
 463                         4,                                  /* size */
 464                         the_insn.exp.X_add_symbol,
 465                         the_insn.exp.X_subtract_symbol,
 466                         the_insn.exp.X_add_number,
 467                         the_insn.pcrel,
 468                         the_insn.reloc);
 469         }
 470         switch (special_case) {
 471
 472         case SPECIAL_CASE_SET:
 473                 special_case = 0;
 474                 assert(the_insn.reloc == RELOC_HI22);
 475                 /* See if "set" operand has no low-order bits; skip OR if so. */
 476                 if (the_insn.exp.X_seg == SEG_ABSOLUTE
 477                     && ((the_insn.exp.X_add_number & 0x3FF) == 0))
 478                     return;
 479                 toP = frag_more(4);
 480                 rsd = (the_insn.opcode >> 25) & 0x1f;
 481                 the_insn.opcode = 0x80102000 | (rsd << 25) | (rsd << 14);
 482                 md_number_to_chars(toP, the_insn.opcode, 4);
 483                 fix_new(frag_now,                           /* which frag */
 484                         (toP - frag_now->fr_literal),       /* where */
 485                         4,                                  /* size */
 486                         the_insn.exp.X_add_symbol,
 487                         the_insn.exp.X_subtract_symbol,
 488                         the_insn.exp.X_add_number,
 489                         the_insn.pcrel,
 490                         RELOC_LO10);
 491                 return;
 492
 493         case SPECIAL_CASE_FDIV:
 494                 /* According to information leaked from Sun, the "fdiv" instructions
 495                    on early SPARC machines would produce incorrect results sometimes.
 496                    The workaround is to add an fmovs of the destination register to
 497                    itself just after the instruction.  This was true on machines
 498                    with Weitek 1165 float chips, such as the Sun-4/260 and /280. */
 499                 special_case = 0;
 500                 assert(the_insn.reloc == NO_RELOC);
 501                 toP = frag_more(4);
 502                 rsd = (the_insn.opcode >> 25) & 0x1f;
 503                 the_insn.opcode = 0x81A00020 | (rsd << 25) | rsd;  /* fmovs dest,dest */
 504                 md_number_to_chars(toP, the_insn.opcode, 4);
 505                 return;
 506
 507         case 0:
 508                 return;
 509
 510         default:
 511                 as_fatal("failed sanity check.");
 512         }
 513 } /* md_assemble() */
 514
 515 static void sparc_ip(str)
 516 char *str;
 517 {
 518         char *error_message = "";
 519         char *s;
 520         const char *args;
 521         char c;
 522         struct sparc_opcode *insn;
 523         char *argsStart;
 524         unsigned long opcode;
 525         unsigned int mask = 0;
 526         int match = 0;
 527         int comma = 0;
 528
 529         for (s = str; islower(*s) || (*s >= '0' && *s <= '3'); ++s)
 530             ;
 531         switch (*s) {
 532
 533         case '\0':
 534                 break;
 535
 536         case ',':
 537                 comma = 1;
 538
 539                 /*FALLTHROUGH */
 540
 541         case ' ':
 542                 *s++ = '\0';
 543                 break;
 544
 545         default:
 546                 as_bad("Unknown opcode: `%s'", str);
 547                 exit(1);
 548         }
 549         if ((insn = (struct sparc_opcode *) hash_find(op_hash, str)) == NULL) {
 550                 as_bad("Unknown opcode: `%s'", str);
 551                 return;
 552         }
 553         if (comma) {
 554                 *--s = ',';
 555         }
 556         argsStart = s;
 557         for (;;) {
 558                 opcode = insn->match;
 559                 memset(&the_insn, '\0', sizeof(the_insn));
 560                 the_insn.reloc = NO_RELOC;
 561
 562                 /*
 563                  * Build the opcode, checking as we go to make
 564                  * sure that the operands match
 565                  */
 566                 for (args = insn->args; ; ++args) {
 567                         switch (*args) {
 568
 569                                 /* start-sanitize-v9 */
 570 #ifndef NO_V9
 571                         case 'K':
 572                           {
 573                             /* Load is 0; Store is 1.
 574                                We compute the mask based on the values
 575                                we find in S.  OK is set set
 576                                if we see something we don't like.  */
 577                             int ok = 1;
 578                             int mask = 0;
 579                             while (ok == 1)
 580                               {
 581                                 int lo = 0, hi = 0;
 582                                 if (*s == '#')
 583                                   {
 584                                     s += 1;
 585                                     if (! (lo = (s[0] == 'S')))
 586                                       ok = (s[0] == 'L');
 587                                     if (! (hi = (s[1] == 'S')))
 588                                       ok = (s[1] == 'L');
 589                                     mask |= (1 << ((hi<<1) | lo));
 590                                     s += 2;
 591                                   }
 592                                 else
 593                                   {
 594                                     /* Parse a number, somehow.  */
 595                                     ok = 0;
 596                                   }
 597                                 if (s[2] != '|')
 598                                   break;
 599                               }
 600                             if (! ok)
 601                               {
 602                                 error_message = "unrecognizable mmask";
 603                                 goto error;
 604                               }
 605                             opcode |= SIMM13(mask);
 606                             continue;
 607                           }
 608
 609                         case '*':
 610                           /* Parse a prefetch function.  */
 611                           if (*s == '#')
 612                             {
 613                               int prefetch_fcn = 0;
 614
 615                               s += 1;
 616                               if (! strncmp (s, "n_reads", 7))
 617                                 prefetch_fcn = 0, s += 7;
 618                               else if (! strncmp (s, "one_read", 8))
 619                                 prefetch_fcn = 1, s += 8;
 620                               else if (! strncmp (s, "n_writes", 8))
 621                                 prefetch_fcn = 2, s += 8;
 622                               else if (! strncmp (s, "one_write", 9))
 623                                 prefetch_fcn = 3, s += 9;
 624                               else if (! strncmp (s, "page", 4))
 625                                 prefetch_fcn = 4, s += 4;
 626                               else
 627                                 {
 628                                   error_message = "unrecognizable prefetch fucntion";
 629                                   goto error;
 630                                 }
 631                             }
 632                           else
 633                             {
 634                               /* Parse a number, somehow.  */
 635                               error_message = "unrecognizable prefetch fucntion";
 636                               goto error;
 637                             }
 638                           continue;
 639
 640                         case '!':
 641                         case '?':
 642                           /* Parse a privileged register.  */
 643                           if (*s == '%')
 644                             {
 645                               struct priv_reg_entry *p = priv_reg_table;
 646                               int len;
 647
 648                               s += 1;
 649                               while (p->name[0] > s[0])
 650                                 p++;
 651                               while (p->name[0] == s[0])
 652                                 {
 653                                   len = strlen (p->name);
 654                                   if (strncmp (p->name, s, len) == 0)
 655                                     break;
 656                                   p++;
 657                                 }
 658                               if (p->name[0] != s[0])
 659                                 {
 660                                   error_message = "unrecognizable privileged register";
 661                                   goto error;
 662                                 }
 663                               if (*args == '?')
 664                                 opcode |= (p->regnum << 14);
 665                               else
 666                                 opcode |= (p->regnum << 25);
 667                               s += len;
 668                               continue;
 669                             }
 670                           else
 671                             {
 672                               error_message = "unrecognizable privileged register";
 673                               goto error;
 674                             }
 675 #endif
 676                                 /* end-sanitize-v9 */
 677
 678                         case 'M':
 679                         case 'm':
 680                                 if (strncmp(s, "%asr", 4) == 0) {
 681                                         s += 4;
 682
 683                                         if (isdigit(*s)) {
 684                                                 long num = 0;
 685
 686                                                 while (isdigit(*s)) {
 687                                                         num = num*10 + *s-'0';
 688                                                         ++s;
 689                                                 }
 690
 691                                                 if (num < 16 || 31 < num) {
 692                                                         error_message = ": asr number must be between 15 and 31";
 693                                                         goto error;
 694                                                 } /* out of range */
 695
 696                                                 opcode |= (*args == 'M' ? RS1(num) : RD(num));
 697                                                 continue;
 698                                         } else {
 699                                                 error_message = ": expecting %asrN";
 700                                                 goto error;
 701                                         } /* if %asr followed by a number. */
 702
 703                                 } /* if %asr */
 704                                 break;
 705
 706                                 /* start-sanitize-v9 */
 707 #ifndef NO_V9
 708                         case 'I':
 709                                 the_insn.reloc = RELOC_11;
 710                                 goto immediate;
 711
 712                         case 'k':
 713                                 the_insn.reloc = RELOC_WDISP2_14;
 714                                 the_insn.pcrel = 1;
 715                                 goto immediate;
 716
 717                         case 'G':
 718                                 the_insn.reloc = RELOC_WDISP19;
 719                                 the_insn.pcrel = 1;
 720                                 goto immediate;
 721
 722                         case 'N':
 723                                 if (*s == 'p' && s[1] == 'n') {
 724                                         s += 2;
 725                                         continue;
 726                                 }
 727                                 break;
 728
 729                         case 'T':
 730                                 if (*s == 'p' && s[1] == 't') {
 731                                         s += 2;
 732                                         continue;
 733                                 }
 734                                 break;
 735
 736                         case 'Y':
 737                                 if (strncmp(s, "%amr", 4) == 0) {
 738                                         s += 4;
 739                                         continue;
 740                                 }
 741                                 break;
 742
 743                         case 'z':
 744                                 if (*s == ' ') {
 745                                         ++s;
 746                                 }
 747                                 if (strncmp(s, "icc", 3) == 0) {
 748                                         s += 3;
 749                                         continue;
 750                                 }
 751                                 break;
 752
 753                         case 'Z':
 754                                 if (*s == ' ') {
 755                                         ++s;
 756                                 }
 757                                 if (strncmp(s, "xcc", 3) == 0) {
 758                                         s += 3;
 759                                         continue;
 760                                 }
 761                                 break;
 762
 763                         case '6':
 764                                 if (*s == ' ') {
 765                                         ++s;
 766                                 }
 767                                 if (strncmp(s, "fcc0", 4) == 0) {
 768                                         s += 4;
 769                                         continue;
 770                                 }
 771                                 break;
 772
 773                         case '7':
 774                                 if (*s == ' ') {
 775                                         ++s;
 776                                 }
 777                                 if (strncmp(s, "fcc1", 4) == 0) {
 778                                         s += 4;
 779                                         continue;
 780                                 }
 781                                 break;
 782
 783                         case '8':
 784                                 if (*s == ' ') {
 785                                         ++s;
 786                                 }
 787                                 if (strncmp(s, "fcc2", 4) == 0) {
 788                                         s += 4;
 789                                         continue;
 790                                 }
 791                                 break;
 792
 793                         case '9':
 794                                 if (*s == ' ') {
 795                                         ++s;
 796                                 }
 797                                 if (strncmp(s, "fcc3", 4) == 0) {
 798                                         s += 4;
 799                                         continue;
 800                                 }
 801                                 break;
 802
 803                         case 'P':
 804                                 if (strncmp(s, "%pc", 3) == 0) {
 805                                         s += 3;
 806                                         continue;
 807                                 }
 808                                 break;
 809
 810                         case 'E':
 811                                 if (strncmp(s, "%modes", 6) == 0) {
 812                                         s += 6;
 813                                         continue;
 814                                 }
 815                                 break;
 816
 817                         case 'W':
 818                                 if (strncmp(s, "%tick", 5) == 0) {
 819                                         s += 5;
 820                                         continue;
 821                                 }
 822                                 break;
 823 #endif /* NO_V9 */
 824                                 /* end-sanitize-v9 */
 825
 826                         case '\0':  /* end of args */
 827                                 if (*s == '\0') {
 828                                         match = 1;
 829                                 }
 830                                 break;
 831
 832                         case '+':
 833                                 if (*s == '+') {
 834                                         ++s;
 835                                         continue;
 836                                 }
 837                                 if (*s == '-') {
 838                                         continue;
 839                                 }
 840                                 break;
 841
 842                         case '[':   /* these must match exactly */
 843                         case ']':
 844                         case ',':
 845                         case ' ':
 846                                 if (*s++ == *args)
 847                                     continue;
 848                                 break;
 849
 850                         case '#':   /* must be at least one digit */
 851                                 if (isdigit(*s++)) {
 852                                         while (isdigit(*s)) {
 853                                                 ++s;
 854                                         }
 855                                         continue;
 856                                 }
 857                                 break;
 858
 859                         case 'C':   /* coprocessor state register */
 860                                 if (strncmp(s, "%csr", 4) == 0) {
 861                                         s += 4;
 862                                         continue;
 863                                 }
 864                                 break;
 865
 866                         case 'b':    /* next operand is a coprocessor register */
 867                         case 'c':
 868                         case 'D':
 869                                 if (*s++ == '%' && *s++ == 'c' && isdigit(*s)) {
 870                                         mask = *s++;
 871                                         if (isdigit(*s)) {
 872                                                 mask = 10 * (mask - '0') + (*s++ - '0');
 873                                                 if (mask >= 32) {
 874                                                         break;
 875                                                 }
 876                                         } else {
 877                                                 mask -= '0';
 878                                         }
 879                                         switch (*args) {
 880
 881                                         case 'b':
 882                                                 opcode |= mask << 14;
 883                                                 continue;
 884
 885                                         case 'c':
 886                                                 opcode |= mask;
 887                                                 continue;
 888
 889                                         case 'D':
 890                                                 opcode |= mask << 25;
 891                                                 continue;
 892                                         }
 893                                 }
 894                                 break;
 895
 896                         case 'r':   /* next operand must be a register */
 897                         case '1':
 898                         case '2':
 899                         case 'd':
 900                                 if (*s++ == '%') {
 901                                         switch (c = *s++) {
 902
 903                                         case 'f':   /* frame pointer */
 904                                                 if (*s++ == 'p') {
 905                                                         mask = 0x1e;
 906                                                         break;
 907                                                 }
 908                                                 goto error;
 909
 910                                         case 'g':   /* global register */
 911                                                 if (isoctal(c = *s++)) {
 912                                                         mask = c - '0';
 913                                                         break;
 914                                                 }
 915                                                 goto error;
 916
 917                                         case 'i':   /* in register */
 918                                                 if (isoctal(c = *s++)) {
 919                                                         mask = c - '0' + 24;
 920                                                         break;
 921                                                 }
 922                                                 goto error;
 923
 924                                         case 'l':   /* local register */
 925                                                 if (isoctal(c = *s++)) {
 926                                                         mask= (c - '0' + 16) ;
 927                                                         break;
 928                                                 }
 929                                                 goto error;
 930
 931                                         case 'o':   /* out register */
 932                                                 if (isoctal(c = *s++)) {
 933                                                         mask= (c - '0' + 8) ;
 934                                                         break;
 935                                                 }
 936                                                 goto error;
 937
 938                                         case 's':   /* stack pointer */
 939                                                 if (*s++ == 'p') {
 940                                                         mask= 0xe;
 941                                                         break;
 942                                                 }
 943                                                 goto error;
 944
 945                                         case 'r': /* any register */
 946                                                 if (!isdigit(c = *s++)) {
 947                                                         goto error;
 948                                                 }
 949                                                 /* FALLTHROUGH */
 950                                         case '0': case '1': case '2': case '3': case '4':
 951                                         case '5': case '6': case '7': case '8': case '9':
 952                                                 if (isdigit(*s)) {
 953                                                         if ((c = 10 * (c - '0') + (*s++ - '0')) >= 32) {
 954                                                                 goto error;
 955                                                         }
 956                                                 } else {
 957                                                         c -= '0';
 958                                                 }
 959                                                 mask= c;
 960                                                 break;
 961
 962                                         default:
 963                                                 goto error;
 964                                         }
 965                                         /*
 966                                          * Got the register, now figure out where
 967                                          * it goes in the opcode.
 968                                          */
 969                                         switch (*args) {
 970
 971                                         case '1':
 972                                                 opcode |= mask << 14;
 973                                                 continue;
 974
 975                                         case '2':
 976                                                 opcode |= mask;
 977                                                 continue;
 978
 979                                         case 'd':
 980                                                 opcode |= mask << 25;
 981                                                 continue;
 982
 983                                         case 'r':
 984                                                 opcode |= (mask << 25) | (mask << 14);
 985                                                 continue;
 986                                         }
 987                                 }
 988                                 break;
 989
 990                                 /* start-sanitize-v9 */
 991 #ifndef NO_V9
 992                         case 'j':
 993                         case 'u':
 994                         case 'U':
 995 #endif /* NO_V9 */
 996                                 /* end-sanitize-v9 */
 997                         case 'e': /* next operand is a floating point register */
 998                         case 'v':
 999                         case 'V':
1000
1001                         case 'f':
1002                         case 'B':
1003                         case 'R':
1004
1005                         case 'g':
1006                         case 'H':
1007                         case 'J': {
1008                                 char format;
1009
1010                                 if (*s++ == '%'
1011
1012                                     /* start-sanitize-v9 */
1013 #ifndef NO_V9
1014                                     && ((format = *s) == 'f'
1015                                         || *s == 'd'
1016                                         || *s == 'q')
1017 #else
1018                                     /* end-sanitize-v9 */
1019                                     && ((format = *s) == 'f')
1020
1021                                     /* start-sanitize-v9 */
1022 #endif /* NO_V9 */
1023                                     /* end-sanitize-v9 */
1024                                     && isdigit(*++s)) {
1025
1026
1027
1028                                         for (mask = 0; isdigit(*s); ++s) {
1029                                                 mask = 10 * mask + (*s - '0');
1030                                         } /* read the number */
1031
1032                                         if ((*args == 'u'
1033                                              || *args == 'v'
1034                                              || *args == 'B'
1035                                              || *args == 'H')
1036                                             && (mask & 1)) {
1037                                                 break;
1038                                         } /* register must be even numbered */
1039
1040                                         if ((*args == 'U'
1041                                              || *args == 'V'
1042                                              || *args == 'R'
1043                                              || *args == 'J')
1044                                             && (mask & 3)) {
1045                                                 break;
1046                                         } /* register must be multiple of 4 */
1047
1048                                         if (format == 'f') {
1049                                                 if (mask >= 32) {
1050                                                         error_message = ": There are only 32 f registers; [0-31]";
1051                                                         goto error;
1052                                                 } /* on error */
1053                                                 /* start-sanitize-v9 */
1054 #ifndef NO_V9
1055                                         } else {
1056                                                 if (format == 'd') {
1057                                                         if (mask >= 64) {
1058                                                                 error_message = ": There are only 32 d registers [0, 2, ... 62].";
1059                                                                 goto error;
1060                                                         } else if (mask & 1) {
1061                                                                 error_message = ": Only even numbered d registers exist.";
1062                                                                 goto error;
1063                                                         } /* on error */
1064
1065                                                 } else if (format == 'q') {
1066                                                         if (mask >= 64) {
1067                                                                 error_message =
1068                                                                     ": There are only 16 q registers [0, 4, ... 60].";
1069                                                                 goto error;
1070                                                         } else if (mask & 3) {
1071                                                                 error_message =
1072                                                                     ": Only q registers evenly divisible by four exist.";
1073                                                                 goto error;
1074                                                         } /* on error */
1075                                                 } else {
1076                                                         know(0);
1077                                                 } /* depending on format */
1078
1079                                                 if (mask >= 32) {
1080                                                         mask -= 31;
1081                                                 } /* wrap high bit */
1082 #endif /* NO_V9 */
1083                                                 /* end-sanitize-v9 */
1084                                         } /* if not an 'f' register. */
1085                                 } /* on error */
1086
1087                                 switch (*args) {
1088                                         /* start-sanitize-v9 */
1089 #ifndef NO_V9
1090                                 case 'j':
1091                                 case 'u':
1092                                 case 'U':
1093                                         opcode |= (mask & 0x1f) << 9;
1094                                         continue;
1095 #endif /* NO_V9 */
1096                                         /* end-sanitize-v9 */
1097
1098                                 case 'v':
1099                                 case 'V':
1100                                 case 'e':
1101                                         opcode |= RS1(mask);
1102                                         continue;
1103
1104
1105                                 case 'f':
1106                                 case 'B':
1107                                 case 'R':
1108                                         opcode |= RS2(mask);
1109                                         continue;
1110
1111                                 case 'g':
1112                                 case 'H':
1113                                 case 'J':
1114                                         opcode |= RD(mask);
1115                                         continue;
1116                                 } /* pack it in. */
1117
1118                                 know(0);
1119                                 break;
1120                         } /* float arg */
1121
1122                         case 'F':
1123                                 if (strncmp(s, "%fsr", 4) == 0) {
1124                                         s += 4;
1125                                         continue;
1126                                 }
1127                                 break;
1128
1129                         case 'h': /* high 22 bits */
1130                                 the_insn.reloc = RELOC_HI22;
1131                                 goto immediate;
1132
1133                         case 'l': /* 22 bit PC relative immediate */
1134                                 the_insn.reloc = RELOC_WDISP22;
1135                                 the_insn.pcrel = 1;
1136                                 goto immediate;
1137
1138                         case 'L': /* 30 bit immediate */
1139                                 the_insn.reloc = RELOC_WDISP30;
1140                                 the_insn.pcrel = 1;
1141                                 goto immediate;
1142
1143                         case 'n': /* 22 bit immediate */
1144                                 the_insn.reloc = RELOC_22;
1145                                 goto immediate;
1146
1147                         case 'i':   /* 13 bit immediate */
1148                                 the_insn.reloc = RELOC_BASE13;
1149
1150                                 /*FALLTHROUGH */
1151
1152                         immediate:
1153                                 if(*s==' ')
1154                                     s++;
1155                                 if (*s == '%') {
1156                                         if ((c = s[1]) == 'h' && s[2] == 'i') {
1157                                                 the_insn.reloc = RELOC_HI22;
1158                                                 s+=3;
1159                                         } else if (c == 'l' && s[2] == 'o') {
1160                                                 the_insn.reloc = RELOC_LO10;
1161                                                 s+=3;
1162                                                 /* start-sanitize-v9 */
1163 #ifndef NO_V9
1164                                         } else if (c == 'h'
1165                                                    && s[2] == 'h'
1166                                                    && s[3] == 'i') {
1167                                                 the_insn.reloc = RELOC_HHI22;
1168                                                 s += 4;
1169
1170                                         } else if (c == 'h'
1171                                                    && s[2] == 'l'
1172                                                    && s[3] == 'o') {
1173                                                 the_insn.reloc = RELOC_HLO10;
1174                                                 s += 4;
1175 #endif /* NO_V9 */
1176                                                 /* end-sanitize-v9 */
1177                                         } else
1178                                             break;
1179                                 }
1180                                 /* Note that if the getExpression() fails, we
1181                                    will still have created U entries in the
1182                                    symbol table for the 'symbols' in the input
1183                                    string.  Try not to create U symbols for
1184                                    registers, etc. */
1185                                 {
1186                                         /* This stuff checks to see if the
1187                                            expression ends in +%reg If it does,
1188                                            it removes the register from the
1189                                            expression, and re-sets 's' to point
1190                                            to the right place */
1191
1192                                         char *s1;
1193
1194                                         for (s1 = s; *s1 && *s1 != ',' && *s1 != ']'; s1++) ;;
1195
1196                                         if (s1 != s && isdigit(s1[-1])) {
1197                                                 if(s1[-2] == '%' && s1[-3] == '+') {
1198                                                         s1 -= 3;
1199                                                         *s1 = '\0';
1200                                                         (void) getExpression(s);
1201                                                         *s1 = '+';
1202                                                         s = s1;
1203                                                         continue;
1204                                                 } else if (strchr("goli0123456789", s1[-2]) && s1[-3] == '%' && s1[-4] == '+') {
1205                                                         s1 -= 4;
1206                                                         *s1 = '\0';
1207                                                         (void) getExpression(s);
1208                                                         *s1 = '+';
1209                                                         s = s1;
1210                                                         continue;
1211                                                 }
1212                                         }
1213                                 }
1214                                 (void)getExpression(s);
1215                                 s = expr_end;
1216                                 continue;
1217
1218                         case 'a':
1219                                 if (*s++ == 'a') {
1220                                         opcode |= ANNUL;
1221                                         continue;
1222                                 }
1223                                 break;
1224
1225                         case 'A': {
1226                                 char *push = input_line_pointer;
1227                                 expressionS e;
1228
1229                                 input_line_pointer = s;
1230
1231                                 if (expression(&e) == SEG_ABSOLUTE) {
1232                                         opcode |= e.X_add_number << 5;
1233                                         s = input_line_pointer;
1234                                         input_line_pointer = push;
1235                                         continue;
1236                                 } /* if absolute */
1237
1238                                 break;
1239                         } /* alternate space */
1240
1241                         case 'p':
1242                                 if (strncmp(s, "%psr", 4) == 0) {
1243                                         s += 4;
1244                                         continue;
1245                                 }
1246                                 break;
1247
1248                         case 'q':   /* floating point queue */
1249                                 if (strncmp(s, "%fq", 3) == 0) {
1250                                         s += 3;
1251                                         continue;
1252                                 }
1253                                 break;
1254
1255                         case 'Q':   /* coprocessor queue */
1256                                 if (strncmp(s, "%cq", 3) == 0) {
1257                                         s += 3;
1258                                         continue;
1259                                 }
1260                                 break;
1261
1262                         case 'S':
1263                                 if (strcmp(str, "set") == 0) {
1264                                         special_case = SPECIAL_CASE_SET;
1265                                         continue;
1266                                 } else if (strncmp(str, "fdiv", 4) == 0) {
1267                                         special_case = SPECIAL_CASE_FDIV;
1268                                         continue;
1269                                 }
1270                                 break;
1271
1272 /* start-sanitize-v9 */
1273 #ifndef NO_V9
1274                         case 's':
1275                           if (strncmp (s, "%usr", 4) != 0)
1276                             break;
1277                           s += 4;
1278                           continue;
1279
1280                         case 'o':
1281                           if (strncmp (s, "%asi", 4) != 0)
1282                             break;
1283                           s += 4;
1284                           continue;
1285 #endif /* NO_V9 */
1286                 /* end-sanitize-v9 */
1287
1288                         case 't':
1289                                 if (strncmp(s, "%tbr", 4) != 0)
1290                                     break;
1291                                 s += 4;
1292                                 continue;
1293
1294                         case 'w':
1295                                 if (strncmp(s, "%wim", 4) != 0)
1296                                     break;
1297                                 s += 4;
1298                                 continue;
1299
1300                         case 'y':
1301                                 if (strncmp(s, "%y", 2) != 0)
1302                                     break;
1303                                 s += 2;
1304                                 continue;
1305
1306                         default:
1307                                 as_fatal("failed sanity check.");
1308                         } /* switch on arg code */
1309                         break;
1310                 } /* for each arg that we expect */
1311         error:
1312                 if (match == 0) {
1313                         /* Args don't match. */
1314                         if (((unsigned) (&insn[1] - sparc_opcodes)) < NUMOPCODES
1315                             && !strcmp(insn->name, insn[1].name)) {
1316                                 ++insn;
1317                                 s = argsStart;
1318                                 continue;
1319                         } else {
1320                                 as_bad("Illegal operands%s", error_message);
1321                                 return;
1322                         }
1323                 } else {
1324                         if (insn->architecture > current_architecture) {
1325                                 if ((!architecture_requested || warn_on_bump)
1326                                     &&
1327 /* start-sanitize-v9 */
1328 #ifndef NO_V9
1329                                     ! ARCHITECTURES_CONFLICT_P (current_architecture,
1330                                                                 insn->architecture)
1331 #else
1332 /* end-sanitize-v9 */
1333                                     1
1334 /* start-sanitize-v9 */
1335 #endif
1336 /* end-sanitize-v9 */
1337                                     ) {
1338                                         if (warn_on_bump) {
1339                                                 as_warn("architecture bumped from \"%s\" to \"%s\" on \"%s\"",
1340                                                         architecture_pname[current_architecture],
1341                                                         architecture_pname[insn->architecture],
1342                                                         str);
1343                                         } /* if warning */
1344
1345                                         current_architecture = insn->architecture;
1346                                 } else {
1347                                         as_bad("architecture mismatch on \"%s\" (\"%s\").  current architecture is \"%s\"",
1348                                                str,
1349                                                architecture_pname[insn->architecture],
1350                                                architecture_pname[current_architecture]);
1351                                         return;
1352                                 } /* if bump ok else error */
1353                         } /* if architecture higher */
1354                 } /* if no match */
1355
1356                 break;
1357         } /* forever looking for a match */
1358
1359         the_insn.opcode = opcode;
1360         return;
1361 } /* sparc_ip() */
1362
1363 static int getExpression(str)
1364 char *str;
1365 {
1366         char *save_in;
1367         segT seg;
1368
1369         save_in = input_line_pointer;
1370         input_line_pointer = str;
1371         switch (seg = expression(&the_insn.exp)) {
1372
1373         case SEG_ABSOLUTE:
1374         case SEG_TEXT:
1375         case SEG_DATA:
1376         case SEG_BSS:
1377         case SEG_UNKNOWN:
1378         case SEG_DIFFERENCE:
1379         case SEG_BIG:
1380         case SEG_ABSENT:
1381                 break;
1382
1383         default:
1384                 the_insn.error = "bad segment";
1385                 expr_end = input_line_pointer;
1386                 input_line_pointer=save_in;
1387                 return 1;
1388         }
1389         expr_end = input_line_pointer;
1390         input_line_pointer = save_in;
1391         return 0;
1392 } /* getExpression() */
1393
1394
1395 /*
1396   This is identical to the md_atof in m68k.c.  I think this is right,
1397   but I'm not sure.
1398
1399   Turn a string in input_line_pointer into a floating point constant of type
1400   type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
1401   emitted is stored in *sizeP .  An error message is returned, or NULL on OK.
1402   */
1403
1404 /* Equal to MAX_PRECISION in atof-ieee.c */
1405 #define MAX_LITTLENUMS 6
1406
1407 char *md_atof(type,litP,sizeP)
1408 char type;
1409 char *litP;
1410 int *sizeP;
1411 {
1412         int prec;
1413         LITTLENUM_TYPE words[MAX_LITTLENUMS];
1414         LITTLENUM_TYPE *wordP;
1415         char *t;
1416         char *atof_ieee();
1417
1418         switch(type) {
1419
1420         case 'f':
1421         case 'F':
1422         case 's':
1423         case 'S':
1424                 prec = 2;
1425                 break;
1426
1427         case 'd':
1428         case 'D':
1429         case 'r':
1430         case 'R':
1431                 prec = 4;
1432                 break;
1433
1434         case 'x':
1435         case 'X':
1436                 prec = 6;
1437                 break;
1438
1439         case 'p':
1440         case 'P':
1441                 prec = 6;
1442                 break;
1443
1444         default:
1445                 *sizeP=0;
1446                 return "Bad call to MD_ATOF()";
1447         }
1448         t=atof_ieee(input_line_pointer,type,words);
1449         if(t)
1450             input_line_pointer=t;
1451         *sizeP=prec * sizeof(LITTLENUM_TYPE);
1452         for(wordP=words;prec--;) {
1453                 md_number_to_chars(litP,(long)(*wordP++),sizeof(LITTLENUM_TYPE));
1454                 litP+=sizeof(LITTLENUM_TYPE);
1455         }
1456         return "";      /* Someone should teach Dean about null pointers */
1457 } /* md_atof() */
1458
1459 /*
1460  * Write out big-endian.
1461  */
1462 void md_number_to_chars(buf,val,n)
1463 char *buf;
1464 long val;
1465 int n;
1466 {
1467
1468         switch(n) {
1469
1470         case 4:
1471                 *buf++ = val >> 24;
1472                 *buf++ = val >> 16;
1473         case 2:
1474                 *buf++ = val >> 8;
1475         case 1:
1476                 *buf = val;
1477                 break;
1478
1479         default:
1480                 as_fatal("failed sanity check.");
1481         }
1482         return;
1483 } /* md_number_to_chars() */
1484
1485 /* Apply a fixS to the frags, now that we know the value it ought to
1486    hold. */
1487
1488 void md_apply_fix(fixP, val)
1489 fixS *fixP;
1490 long val;
1491 {
1492         char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
1493
1494         assert(fixP->fx_size == 4);
1495         assert(fixP->fx_r_type < NO_RELOC);
1496
1497         fixP->fx_addnumber = val;       /* Remember value for emit_reloc */
1498
1499         /*
1500          * This is a hack.  There should be a better way to
1501          * handle this.
1502          */
1503         if (fixP->fx_r_type == RELOC_WDISP30 && fixP->fx_addsy) {
1504                 val += fixP->fx_where + fixP->fx_frag->fr_address;
1505         }
1506
1507         switch (fixP->fx_r_type) {
1508
1509         case RELOC_32:
1510                 buf[0] = 0; /* val >> 24; */
1511                 buf[1] = 0; /* val >> 16; */
1512                 buf[2] = 0; /* val >> 8; */
1513                 buf[3] = 0; /* val; */
1514                 break;
1515
1516 #if 0
1517         case RELOC_8:         /* These don't seem to ever be needed. */
1518         case RELOC_16:
1519         case RELOC_DISP8:
1520         case RELOC_DISP16:
1521         case RELOC_DISP32:
1522 #endif
1523         case RELOC_WDISP30:
1524                 val = (val >>= 2) + 1;
1525                 buf[0] |= (val >> 24) & 0x3f;
1526                 buf[1]= (val >> 16);
1527                 buf[2] = val >> 8;
1528                 buf[3] = val;
1529                 break;
1530
1531                 /* start-sanitize-v9 */
1532 #ifndef NO_V9
1533         case RELOC_11:
1534                 if (((val > 0) && (val & ~0x7ff))
1535                     || ((val < 0) && (~(val - 1) & ~0x7ff))) {
1536                         as_bad("relocation overflow.");
1537                 } /* on overflow */
1538
1539                 buf[2] = (val >> 8) & 0x7;
1540                 buf[3] = val & 0xff;
1541                 break;
1542
1543         case RELOC_WDISP2_14:
1544                 if (((val > 0) && (val & ~0x3fffc))
1545                     || ((val < 0) && (~(val - 1) & ~0x3fffc))) {
1546                         as_bad("relocation overflow.");
1547                 } /* on overflow */
1548
1549                 val = (val >>= 2) + 1;
1550                 buf[1] |= ((val >> 14) & 0x3) << 3;
1551                 buf[2] |= (val >> 8) & 0x3f ;
1552                 buf[3] = val & 0xff;
1553                 break;
1554
1555         case RELOC_WDISP19:
1556                 if (((val > 0) && (val & ~0x1ffffc))
1557                     || ((val < 0) && (~(val - 1) & ~0x1ffffc))) {
1558                         as_bad("relocation overflow.");
1559                 } /* on overflow */
1560
1561                 val = (val >>= 2) + 1;
1562                 buf[1] |= (val >> 16) & 0x7;
1563                 buf[2] = (val >> 8) & 0xff;
1564                 buf[3] = val & 0xff;
1565                 break;
1566
1567         case RELOC_HHI22:
1568                 val >>= 32;
1569                 /* intentional fallthrough */
1570 #endif /* NO_V9 */
1571                 /* end-sanitize-v9 */
1572
1573         case RELOC_HI22:
1574                 if(!fixP->fx_addsy) {
1575                         buf[1] |= (val >> 26) & 0x3f;
1576                         buf[2] = val >> 18;
1577                         buf[3] = val >> 10;
1578                 } else {
1579                         buf[2]=0;
1580                         buf[3]=0;
1581                 }
1582                 break;
1583
1584         case RELOC_22:
1585                 if (val & ~0x003fffff) {
1586                         as_bad("relocation overflow");
1587                 } /* on overflow */
1588                 buf[1] |= (val >> 16) & 0x3f;
1589                 buf[2] = val >> 8;
1590                 buf[3] = val & 0xff;
1591                 break;
1592
1593         case RELOC_13:
1594                 if (val & ~0x00001fff) {
1595                         as_bad("relocation overflow");
1596                 } /* on overflow */
1597                 buf[2] = (val >> 8) & 0x1f;
1598                 buf[3] = val & 0xff;
1599                 break;
1600
1601                 /* start-sanitize-v9 */
1602 #ifndef NO_V9
1603         case RELOC_HLO10:
1604                 val >>= 32;
1605                 /* intentional fallthrough */
1606 #endif /* NO_V9 */
1607                 /* end-sanitize-v9 */
1608
1609         case RELOC_LO10:
1610                 if(!fixP->fx_addsy) {
1611                         buf[2] |= (val >> 8) & 0x03;
1612                         buf[3] = val;
1613                 } else
1614                     buf[3]=0;
1615                 break;
1616 #if 0
1617         case RELOC_SFA_BASE:
1618         case RELOC_SFA_OFF13:
1619         case RELOC_BASE10:
1620 #endif
1621         case RELOC_BASE13:
1622                 buf[2] |= (val >> 8) & 0x1f;
1623                 buf[3] = val;
1624                 break;
1625
1626         case RELOC_WDISP22:
1627                 val = (val >>= 2) + 1;
1628                 /* FALLTHROUGH */
1629         case RELOC_BASE22:
1630                 buf[1] |= (val >> 16) & 0x3f;
1631                 buf[2] = val >> 8;
1632                 buf[3] = val;
1633                 break;
1634
1635 #if 0
1636         case RELOC_PC10:
1637         case RELOC_PC22:
1638         case RELOC_JMP_TBL:
1639         case RELOC_SEGOFF16:
1640         case RELOC_GLOB_DAT:
1641         case RELOC_JMP_SLOT:
1642         case RELOC_RELATIVE:
1643 #endif
1644
1645         case NO_RELOC:
1646         default:
1647                 as_bad("bad relocation type: 0x%02x", fixP->fx_r_type);
1648                 break;
1649         }
1650 } /* md_apply_fix() */
1651
1652 /* should never be called for sparc */
1653 void md_create_short_jump(ptr, from_addr, to_addr, frag, to_symbol)
1654 char *ptr;
1655 long from_addr;
1656 long to_addr;
1657 fragS *frag;
1658 symbolS *to_symbol;
1659 {
1660         as_fatal("sparc_create_short_jmp\n");
1661 } /* md_create_short_jump() */
1662
1663 /* Translate internal representation of relocation info to target format.
1664
1665    On sparc: first 4 bytes are normal unsigned long address, next three
1666    bytes are index, most sig. byte first.  Byte 7 is broken up with
1667    bit 7 as external, bits 6 & 5 unused, and the lower
1668    five bits as relocation type.  Next 4 bytes are long addend. */
1669 /* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com */
1670 void
1671 tc_aout_fix_to_chars(where, fixP, segment_address_in_file)
1672      char *where;
1673      fixS *fixP;
1674      relax_addressT segment_address_in_file;
1675 {
1676         long r_index;
1677         long r_extern;
1678         long r_addend = 0;
1679         long r_address;
1680
1681         know(fixP->fx_addsy);
1682
1683         if (!S_IS_DEFINED(fixP->fx_addsy)) {
1684                 r_extern = 1;
1685                 r_index = fixP->fx_addsy->sy_number;
1686         } else {
1687                 r_extern = 0;
1688                 r_index = S_GET_TYPE(fixP->fx_addsy);
1689         }
1690
1691         /* this is easy */
1692         md_number_to_chars(where,
1693                            r_address = fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
1694                            4);
1695
1696         /* now the fun stuff */
1697         where[4] = (r_index >> 16) & 0x0ff;
1698         where[5] = (r_index >> 8) & 0x0ff;
1699         where[6] = r_index & 0x0ff;
1700         where[7] = ((r_extern << 7)  & 0x80) | (0 & 0x60) | (fixP->fx_r_type & 0x1F);
1701
1702         /* Also easy */
1703         if (fixP->fx_addsy->sy_frag) {
1704                 r_addend = fixP->fx_addsy->sy_frag->fr_address;
1705         }
1706
1707         if (fixP->fx_pcrel) {
1708                 r_addend += fixP->fx_offset - r_address;
1709         } else {
1710                 r_addend = fixP->fx_addnumber;
1711         }
1712
1713         md_number_to_chars(&where[8], r_addend, 4);
1714
1715         return;
1716 } /* tc_aout_fix_to_chars() */
1717
1718 /* should never be called for sparc */
1719 void md_convert_frag(headers, fragP)
1720 object_headers *headers;
1721 register fragS *fragP;
1722 {
1723         as_fatal("sparc_convert_frag\n");
1724 } /* md_convert_frag() */
1725
1726 /* should never be called for sparc */
1727 void md_create_long_jump(ptr, from_addr, to_addr, frag, to_symbol)
1728 char *ptr;
1729 long from_addr, to_addr;
1730 fragS   *frag;
1731 symbolS *to_symbol;
1732 {
1733         as_fatal("sparc_create_long_jump\n");
1734 } /* md_create_long_jump() */
1735
1736 /* should never be called for sparc */
1737 int md_estimate_size_before_relax(fragP, segtype)
1738 fragS *fragP;
1739 segT segtype;
1740 {
1741         as_fatal("sparc_estimate_size_before_relax\n");
1742         return(1);
1743 } /* md_estimate_size_before_relax() */
1744
1745 #if 0
1746 /* for debugging only */
1747 static void print_insn(insn)
1748 struct sparc_it *insn;
1749 {
1750         char *Reloc[] = {
1751                 "RELOC_8",
1752                 "RELOC_16",
1753                 "RELOC_32",
1754                 "RELOC_DISP8",
1755                 "RELOC_DISP16",
1756                 "RELOC_DISP32",
1757                 "RELOC_WDISP30",
1758                 "RELOC_WDISP22",
1759                 "RELOC_HI22",
1760                 "RELOC_22",
1761                 "RELOC_13",
1762                 "RELOC_LO10",
1763                 "RELOC_SFA_BASE",
1764                 "RELOC_SFA_OFF13",
1765                 "RELOC_BASE10",
1766                 "RELOC_BASE13",
1767                 "RELOC_BASE22",
1768                 "RELOC_PC10",
1769                 "RELOC_PC22",
1770                 "RELOC_JMP_TBL",
1771                 "RELOC_SEGOFF16",
1772                 "RELOC_GLOB_DAT",
1773                 "RELOC_JMP_SLOT",
1774                 "RELOC_RELATIVE",
1775                 "NO_RELOC"
1776             };
1777
1778         if (insn->error) {
1779                 fprintf(stderr, "ERROR: %s\n");
1780         }
1781         fprintf(stderr, "opcode=0x%08x\n", insn->opcode);
1782         fprintf(stderr, "reloc = %s\n", Reloc[insn->reloc]);
1783         fprintf(stderr, "exp = {
1784 \n");
1785         fprintf(stderr, "\t\tX_add_symbol = %s\n",
1786                 ((insn->exp.X_add_symbol != NULL)
1787                  ? ((S_GET_NAME(insn->exp.X_add_symbol) != NULL)
1788                     ? S_GET_NAME(insn->exp.X_add_symbol)
1789                     : "???")
1790                  : "0"));
1791         fprintf(stderr, "\t\tX_sub_symbol = %s\n",
1792                 ((insn->exp.X_subtract_symbol != NULL)
1793                  ? (S_GET_NAME(insn->exp.X_subtract_symbol)
1794                     ? S_GET_NAME(insn->exp.X_subtract_symbol)
1795                     : "???")
1796                  : "0"));
1797         fprintf(stderr, "\t\tX_add_number = %d\n",
1798                 insn->exp.X_add_number);
1799         fprintf(stderr, "}\n");
1800         return;
1801 } /* print_insn() */
1802 #endif
1803
1804 /* Set the hook... */
1805
1806 /* void emit_sparc_reloc();
1807    void (*md_emit_relocations)() = emit_sparc_reloc; */
1808
1809 #ifdef comment
1810
1811 /*
1812  * Sparc/AM29K relocations are completely different, so it needs
1813  * this machine dependent routine to emit them.
1814  */
1815 #if defined(OBJ_AOUT) || defined(OBJ_BOUT)
1816 void emit_sparc_reloc(fixP, segment_address_in_file)
1817 register fixS *fixP;
1818 relax_addressT segment_address_in_file;
1819 {
1820         struct reloc_info_generic ri;
1821         register symbolS *symbolP;
1822         extern char *next_object_file_charP;
1823         /*    long add_number; */
1824
1825         memset((char *) &ri, '\0', sizeof(ri));
1826         for (; fixP; fixP = fixP->fx_next) {
1827
1828                 if (fixP->fx_r_type >= NO_RELOC) {
1829                         as_fatal("fixP->fx_r_type = %d\n", fixP->fx_r_type);
1830                 }
1831
1832                 if ((symbolP = fixP->fx_addsy) != NULL) {
1833                         ri.r_address = fixP->fx_frag->fr_address +
1834                             fixP->fx_where - segment_address_in_file;
1835                         if ((S_GET_TYPE(symbolP)) == N_UNDF) {
1836                                 ri.r_extern = 1;
1837                                 ri.r_index = symbolP->sy_number;
1838                         } else {
1839                                 ri.r_extern = 0;
1840                                 ri.r_index = S_GET_TYPE(symbolP);
1841                         }
1842                         if (symbolP && symbolP->sy_frag) {
1843                                 ri.r_addend = symbolP->sy_frag->fr_address;
1844                         }
1845                         ri.r_type = fixP->fx_r_type;
1846                         if (fixP->fx_pcrel) {
1847                                 /*              ri.r_addend -= fixP->fx_where; */
1848                                 ri.r_addend -= ri.r_address;
1849                         } else {
1850                                 ri.r_addend = fixP->fx_addnumber;
1851                         }
1852
1853                         md_ri_to_chars(next_object_file_charP, &ri);
1854                         next_object_file_charP += md_reloc_size;
1855                 }
1856         }
1857         return;
1858 } /* emit_sparc_reloc() */
1859 #endif /* aout or bout */
1860 #endif /* comment */
1861
1862 /*
1863  * md_parse_option
1864  *      Invocation line includes a switch not recognized by the base assembler.
1865  *      See if it's a processor-specific option.  These are:
1866  *
1867  *      -bump
1868  *              Warn on architecture bumps.  See also -A.
1869  *
1870  *      -Av6, -Av7, -Av8, -Asparclite
1871  *              Select the architecture.  Instructions or features not
1872  *              supported by the selected architecture cause fatal errors.
1873  *
1874  *              The default is to start at v6, and bump the architecture up
1875  *              whenever an instruction is seen at a higher level.
1876  *
1877  *              If -bump is specified, a warning is printing when bumping to
1878  *              higher levels.
1879  *
1880  *              If an architecture is specified, all instructions must match
1881  *              that architecture.  Any higher level instructions are flagged
1882  *              as errors.
1883  *
1884  *              if both an architecture and -bump are specified, the
1885  *              architecture starts at the specified level, but bumps are
1886  *              warnings.
1887  *
1888  * start-sanitize-v9
1889  *              Bumping between incompatible architectures is always an
1890  *              error.  For example, from sparclite to v9.
1891  * end-sanitize-v9
1892  */
1893 /* start-sanitize-v9 */
1894 /* There is also a -Av9 architecture option.  xoxorich. */
1895 /* end-sanitize-v9 */
1896 int md_parse_option(argP, cntP, vecP)
1897 char **argP;
1898 int *cntP;
1899 char ***vecP;
1900 {
1901         char *p;
1902         const char **arch;
1903
1904         if (!strcmp(*argP,"bump")){
1905                 warn_on_bump = 1;
1906
1907         } else if (**argP == 'A'){
1908                 p = (*argP) + 1;
1909
1910                 for (arch = architecture_pname; *arch != NULL; ++arch){
1911                         if (strcmp(p, *arch) == 0){
1912                                 break;
1913                         } /* found a match */
1914                 } /* walk the pname table */
1915
1916                 if (*arch == NULL){
1917                         as_bad("unknown architecture: %s", p);
1918                 } else {
1919                         current_architecture = (enum sparc_architecture) (arch - architecture_pname);
1920                         architecture_requested = 1;
1921                 }
1922         } else {
1923                 /* Unknown option */
1924                 (*argP)++;
1925                 return 0;
1926         }
1927         **argP = '\0';  /* Done parsing this switch */
1928         return 1;
1929 } /* md_parse_option() */
1930
1931 /* We have no need to default values of symbols. */
1932
1933 /* ARGSUSED */
1934 symbolS *md_undefined_symbol(name)
1935 char *name;
1936 {
1937         return 0;
1938 } /* md_undefined_symbol() */
1939
1940 /* Parse an operand that is machine-specific.
1941    We just return without modifying the expression if we have nothing
1942    to do. */
1943
1944 /* ARGSUSED */
1945 void md_operand(expressionP)
1946 expressionS *expressionP;
1947 {
1948 } /* md_operand() */
1949
1950 /* Round up a section size to the appropriate boundary. */
1951 long md_section_align (segment, size)
1952 segT segment;
1953 long size;
1954 {
1955         return (size + 7) & ~7; /* Round all sects to multiple of 8 */
1956 } /* md_section_align() */
1957
1958 /* Exactly what point is a PC-relative offset relative TO?
1959    On the sparc, they're relative to the address of the offset, plus
1960    its size.  This gets us to the following instruction.
1961    (??? Is this right?  FIXME-SOON) */
1962 long md_pcrel_from(fixP)
1963 fixS *fixP;
1964 {
1965         return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
1966 } /* md_pcrel_from() */
1967
1968 void tc_aout_pre_write_hook(headers)
1969 object_headers *headers;
1970 {
1971         H_SET_VERSION(headers, 1);
1972         return;
1973 } /* tc_aout_pre_write_hook() */
1974
1975 /*
1976  * Local Variables:
1977  * comment-column: 0
1978  * fill-column: 131
1979  * End:
1980  */
1981
1982 /* end of tc-sparc.c */