gas/config/tc-sparc.c

   1 /* tc-sparc.c -- Assemble for the SPARC
   2    Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003
   4    Free Software Foundation, Inc.
   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
  18    License along with GAS; see the file COPYING.  If not, write
  19    to the Free Software Foundation, 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include <stdio.h>
  23
  24 #include "as.h"
  25 #include "safe-ctype.h"
  26 #include "subsegs.h"
  27
  28 #include "opcode/sparc.h"
  29 #include "dw2gencfi.h"
  30
  31 #ifdef OBJ_ELF
  32 #include "elf/sparc.h"
  33 #include "dwarf2dbg.h"
  34 #endif
  35
  36 /* Some ancient Sun C compilers would not take such hex constants as
  37    unsigned, and would end up sign-extending them to form an offsetT,
  38    so use these constants instead.  */
  39 #define U0xffffffff ((((unsigned long) 1 << 16) << 16) - 1)
  40 #define U0x80000000 ((((unsigned long) 1 << 16) << 15))
  41
  42 static struct sparc_arch *lookup_arch PARAMS ((char *));
  43 static void init_default_arch PARAMS ((void));
  44 static int sparc_ip PARAMS ((char *, const struct sparc_opcode **));
  45 static int in_signed_range PARAMS ((bfd_signed_vma, bfd_signed_vma));
  46 static int in_unsigned_range PARAMS ((bfd_vma, bfd_vma));
  47 static int in_bitfield_range PARAMS ((bfd_signed_vma, bfd_signed_vma));
  48 static int sparc_ffs PARAMS ((unsigned int));
  49 static void synthetize_setuw PARAMS ((const struct sparc_opcode *));
  50 static void synthetize_setsw PARAMS ((const struct sparc_opcode *));
  51 static void synthetize_setx PARAMS ((const struct sparc_opcode *));
  52 static bfd_vma BSR PARAMS ((bfd_vma, int));
  53 static int cmp_reg_entry PARAMS ((const PTR, const PTR));
  54 static int parse_keyword_arg PARAMS ((int (*) (const char *), char **, int *));
  55 static int parse_const_expr_arg PARAMS ((char **, int *));
  56 static int get_expression PARAMS ((char *str));
  57
  58 /* Default architecture.  */
  59 /* ??? The default value should be V8, but sparclite support was added
  60    by making it the default.  GCC now passes -Asparclite, so maybe sometime in
  61    the future we can set this to V8.  */
  62 #ifndef DEFAULT_ARCH
  63 #define DEFAULT_ARCH "sparclite"
  64 #endif
  65 static char *default_arch = DEFAULT_ARCH;
  66
  67 /* Non-zero if the initial values of `max_architecture' and `sparc_arch_size'
  68    have been set.  */
  69 static int default_init_p;
  70
  71 /* Current architecture.  We don't bump up unless necessary.  */
  72 static enum sparc_opcode_arch_val current_architecture = SPARC_OPCODE_ARCH_V6;
  73
  74 /* The maximum architecture level we can bump up to.
  75    In a 32 bit environment, don't allow bumping up to v9 by default.
  76    The native assembler works this way.  The user is required to pass
  77    an explicit argument before we'll create v9 object files.  However, if
  78    we don't see any v9 insns, a v8plus object file is not created.  */
  79 static enum sparc_opcode_arch_val max_architecture;
  80
  81 /* Either 32 or 64, selects file format.  */
  82 static int sparc_arch_size;
  83 /* Initial (default) value, recorded separately in case a user option
  84    changes the value before md_show_usage is called.  */
  85 static int default_arch_size;
  86
  87 #ifdef OBJ_ELF
  88 /* The currently selected v9 memory model.  Currently only used for
  89    ELF.  */
  90 static enum { MM_TSO, MM_PSO, MM_RMO } sparc_memory_model = MM_RMO;
  91 #endif
  92
  93 static int architecture_requested;
  94 static int warn_on_bump;
  95
  96 /* If warn_on_bump and the needed architecture is higher than this
  97    architecture, issue a warning.  */
  98 static enum sparc_opcode_arch_val warn_after_architecture;
  99
 100 /* Non-zero if as should generate error if an undeclared g[23] register
 101    has been used in -64.  */
 102 static int no_undeclared_regs;
 103
 104 /* Non-zero if we should try to relax jumps and calls.  */
 105 static int sparc_relax;
 106
 107 /* Non-zero if we are generating PIC code.  */
 108 int sparc_pic_code;
 109
 110 /* Non-zero if we should give an error when misaligned data is seen.  */
 111 static int enforce_aligned_data;
 112
 113 extern int target_big_endian;
 114
 115 static int target_little_endian_data;
 116
 117 /* Symbols for global registers on v9.  */
 118 static symbolS *globals[8];
 119
 120 /* The dwarf2 data alignment, adjusted for 32 or 64 bit.  */
 121 int sparc_cie_data_alignment;
 122
 123 /* V9 and 86x have big and little endian data, but instructions are always big
 124    endian.  The sparclet has bi-endian support but both data and insns have
 125    the same endianness.  Global `target_big_endian' is used for data.
 126    The following macro is used for instructions.  */
 127 #ifndef INSN_BIG_ENDIAN
 128 #define INSN_BIG_ENDIAN (target_big_endian \
 129                          || default_arch_type == sparc86x \
 130                          || SPARC_OPCODE_ARCH_V9_P (max_architecture))
 131 #endif
 132
 133 /* Handle of the OPCODE hash table.  */
 134 static struct hash_control *op_hash;
 135
 136 static int log2 PARAMS ((int));
 137 static void s_data1 PARAMS ((void));
 138 static void s_seg PARAMS ((int));
 139 static void s_proc PARAMS ((int));
 140 static void s_reserve PARAMS ((int));
 141 static void s_common PARAMS ((int));
 142 static void s_empty PARAMS ((int));
 143 static void s_uacons PARAMS ((int));
 144 static void s_ncons PARAMS ((int));
 145 #ifdef OBJ_ELF
 146 static void s_register PARAMS ((int));
 147 #endif
 148
 149 const pseudo_typeS md_pseudo_table[] =
 150 {
 151   {"align", s_align_bytes, 0},  /* Defaulting is invalid (0).  */
 152   {"common", s_common, 0},
 153   {"empty", s_empty, 0},
 154   {"global", s_globl, 0},
 155   {"half", cons, 2},
 156   {"nword", s_ncons, 0},
 157   {"optim", s_ignore, 0},
 158   {"proc", s_proc, 0},
 159   {"reserve", s_reserve, 0},
 160   {"seg", s_seg, 0},
 161   {"skip", s_space, 0},
 162   {"word", cons, 4},
 163   {"xword", cons, 8},
 164   {"uahalf", s_uacons, 2},
 165   {"uaword", s_uacons, 4},
 166   {"uaxword", s_uacons, 8},
 167 #ifdef OBJ_ELF
 168   /* These are specific to sparc/svr4.  */
 169   {"2byte", s_uacons, 2},
 170   {"4byte", s_uacons, 4},
 171   {"8byte", s_uacons, 8},
 172   {"register", s_register, 0},
 173 #endif
 174   {NULL, 0, 0},
 175 };
 176
 177 /* Size of relocation record.  */
 178 const int md_reloc_size = 12;
 179
 180 /* This array holds the chars that always start a comment.  If the
 181    pre-processor is disabled, these aren't very useful.  */
 182 const char comment_chars[] = "!";       /* JF removed '|' from
 183                                            comment_chars.  */
 184
 185 /* This array holds the chars that only start a comment at the beginning of
 186    a line.  If the line seems to have the form '# 123 filename'
 187    .line and .file directives will appear in the pre-processed output.  */
 188 /* Note that input_file.c hand checks for '#' at the beginning of the
 189    first line of the input file.  This is because the compiler outputs
 190    #NO_APP at the beginning of its output.  */
 191 /* Also note that comments started like this one will always
 192    work if '/' isn't otherwise defined.  */
 193 const char line_comment_chars[] = "#";
 194
 195 const char line_separator_chars[] = ";";
 196
 197 /* Chars that can be used to separate mant from exp in floating point
 198    nums.  */
 199 const char EXP_CHARS[] = "eE";
 200
 201 /* Chars that mean this number is a floating point constant.
 202    As in 0f12.456
 203    or    0d1.2345e12  */
 204 const char FLT_CHARS[] = "rRsSfFdDxXpP";
 205
 206 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
 207    changed in read.c.  Ideally it shouldn't have to know about it at all,
 208    but nothing is ideal around here.  */
 209
 210 #define isoctal(c)  ((unsigned) ((c) - '0') < '8')
 211
 212 struct sparc_it
 213   {
 214     char *error;
 215     unsigned long opcode;
 216     struct nlist *nlistp;
 217     expressionS exp;
 218     expressionS exp2;
 219     int pcrel;
 220     bfd_reloc_code_real_type reloc;
 221   };
 222
 223 struct sparc_it the_insn, set_insn;
 224
 225 static void output_insn
 226   PARAMS ((const struct sparc_opcode *, struct sparc_it *));
 227 \f
 228 /* Table of arguments to -A.
 229    The sparc_opcode_arch table in sparc-opc.c is insufficient and incorrect
 230    for this use.  That table is for opcodes only.  This table is for opcodes
 231    and file formats.  */
 232
 233 enum sparc_arch_types {v6, v7, v8, sparclet, sparclite, sparc86x, v8plus,
 234                        v8plusa, v9, v9a, v9b, v9_64};
 235
 236 static struct sparc_arch {
 237   char *name;
 238   char *opcode_arch;
 239   enum sparc_arch_types arch_type;
 240   /* Default word size, as specified during configuration.
 241      A value of zero means can't be used to specify default architecture.  */
 242   int default_arch_size;
 243   /* Allowable arg to -A?  */
 244   int user_option_p;
 245 } sparc_arch_table[] = {
 246   { "v6", "v6", v6, 0, 1 },
 247   { "v7", "v7", v7, 0, 1 },
 248   { "v8", "v8", v8, 32, 1 },
 249   { "sparclet", "sparclet", sparclet, 32, 1 },
 250   { "sparclite", "sparclite", sparclite, 32, 1 },
 251   { "sparc86x", "sparclite", sparc86x, 32, 1 },
 252   { "v8plus", "v9", v9, 0, 1 },
 253   { "v8plusa", "v9a", v9, 0, 1 },
 254   { "v8plusb", "v9b", v9, 0, 1 },
 255   { "v9", "v9", v9, 0, 1 },
 256   { "v9a", "v9a", v9, 0, 1 },
 257   { "v9b", "v9b", v9, 0, 1 },
 258   /* This exists to allow configure.in/Makefile.in to pass one
 259      value to specify both the default machine and default word size.  */
 260   { "v9-64", "v9", v9, 64, 0 },
 261   { NULL, NULL, v8, 0, 0 }
 262 };
 263
 264 /* Variant of default_arch */
 265 static enum sparc_arch_types default_arch_type;
 266
 267 static struct sparc_arch *
 268 lookup_arch (name)
 269      char *name;
 270 {
 271   struct sparc_arch *sa;
 272
 273   for (sa = &sparc_arch_table[0]; sa->name != NULL; sa++)
 274     if (strcmp (sa->name, name) == 0)
 275       break;
 276   if (sa->name == NULL)
 277     return NULL;
 278   return sa;
 279 }
 280
 281 /* Initialize the default opcode arch and word size from the default
 282    architecture name.  */
 283
 284 static void
 285 init_default_arch ()
 286 {
 287   struct sparc_arch *sa = lookup_arch (default_arch);
 288
 289   if (sa == NULL
 290       || sa->default_arch_size == 0)
 291     as_fatal (_("Invalid default architecture, broken assembler."));
 292
 293   max_architecture = sparc_opcode_lookup_arch (sa->opcode_arch);
 294   if (max_architecture == SPARC_OPCODE_ARCH_BAD)
 295     as_fatal (_("Bad opcode table, broken assembler."));
 296   default_arch_size = sparc_arch_size = sa->default_arch_size;
 297   default_init_p = 1;
 298   default_arch_type = sa->arch_type;
 299 }
 300
 301 /* Called by TARGET_FORMAT.  */
 302
 303 const char *
 304 sparc_target_format ()
 305 {
 306   /* We don't get a chance to initialize anything before we're called,
 307      so handle that now.  */
 308   if (! default_init_p)
 309     init_default_arch ();
 310
 311 #ifdef OBJ_AOUT
 312 #ifdef TE_NetBSD
 313   return "a.out-sparc-netbsd";
 314 #else
 315 #ifdef TE_SPARCAOUT
 316   if (target_big_endian)
 317     return "a.out-sunos-big";
 318   else if (default_arch_type == sparc86x && target_little_endian_data)
 319     return "a.out-sunos-big";
 320   else
 321     return "a.out-sparc-little";
 322 #else
 323   return "a.out-sunos-big";
 324 #endif
 325 #endif
 326 #endif
 327
 328 #ifdef OBJ_BOUT
 329   return "b.out.big";
 330 #endif
 331
 332 #ifdef OBJ_COFF
 333 #ifdef TE_LYNX
 334   return "coff-sparc-lynx";
 335 #else
 336   return "coff-sparc";
 337 #endif
 338 #endif
 339
 340 #ifdef OBJ_ELF
 341   return sparc_arch_size == 64 ? "elf64-sparc" : "elf32-sparc";
 342 #endif
 343
 344   abort ();
 345 }
 346 \f
 347 /* md_parse_option
 348  *      Invocation line includes a switch not recognized by the base assembler.
 349  *      See if it's a processor-specific option.  These are:
 350  *
 351  *      -bump
 352  *              Warn on architecture bumps.  See also -A.
 353  *
 354  *      -Av6, -Av7, -Av8, -Asparclite, -Asparclet
 355  *              Standard 32 bit architectures.
 356  *      -Av9, -Av9a, -Av9b
 357  *              Sparc64 in either a 32 or 64 bit world (-32/-64 says which).
 358  *              This used to only mean 64 bits, but properly specifying it
 359  *              complicated gcc's ASM_SPECs, so now opcode selection is
 360  *              specified orthogonally to word size (except when specifying
 361  *              the default, but that is an internal implementation detail).
 362  *      -Av8plus, -Av8plusa, -Av8plusb
 363  *              Same as -Av9{,a,b}.
 364  *      -xarch=v8plus, -xarch=v8plusa, -xarch=v8plusb
 365  *              Same as -Av8plus{,a,b} -32, for compatibility with Sun's
 366  *              assembler.
 367  *      -xarch=v9, -xarch=v9a, -xarch=v9b
 368  *              Same as -Av9{,a,b} -64, for compatibility with Sun's
 369  *              assembler.
 370  *
 371  *              Select the architecture and possibly the file format.
 372  *              Instructions or features not supported by the selected
 373  *              architecture cause fatal errors.
 374  *
 375  *              The default is to start at v6, and bump the architecture up
 376  *              whenever an instruction is seen at a higher level.  In 32 bit
 377  *              environments, v9 is not bumped up to, the user must pass
 378  *              -Av8plus{,a,b}.
 379  *
 380  *              If -bump is specified, a warning is printing when bumping to
 381  *              higher levels.
 382  *
 383  *              If an architecture is specified, all instructions must match
 384  *              that architecture.  Any higher level instructions are flagged
 385  *              as errors.  Note that in the 32 bit environment specifying
 386  *              -Av8plus does not automatically create a v8plus object file, a
 387  *              v9 insn must be seen.
 388  *
 389  *              If both an architecture and -bump are specified, the
 390  *              architecture starts at the specified level, but bumps are
 391  *              warnings.  Note that we can't set `current_architecture' to
 392  *              the requested level in this case: in the 32 bit environment,
 393  *              we still must avoid creating v8plus object files unless v9
 394  *              insns are seen.
 395  *
 396  * Note:
 397  *              Bumping between incompatible architectures is always an
 398  *              error.  For example, from sparclite to v9.
 399  */
 400
 401 #ifdef OBJ_ELF
 402 const char *md_shortopts = "A:K:VQ:sq";
 403 #else
 404 #ifdef OBJ_AOUT
 405 const char *md_shortopts = "A:k";
 406 #else
 407 const char *md_shortopts = "A:";
 408 #endif
 409 #endif
 410 struct option md_longopts[] = {
 411 #define OPTION_BUMP (OPTION_MD_BASE)
 412   {"bump", no_argument, NULL, OPTION_BUMP},
 413 #define OPTION_SPARC (OPTION_MD_BASE + 1)
 414   {"sparc", no_argument, NULL, OPTION_SPARC},
 415 #define OPTION_XARCH (OPTION_MD_BASE + 2)
 416   {"xarch", required_argument, NULL, OPTION_XARCH},
 417 #ifdef OBJ_ELF
 418 #define OPTION_32 (OPTION_MD_BASE + 3)
 419   {"32", no_argument, NULL, OPTION_32},
 420 #define OPTION_64 (OPTION_MD_BASE + 4)
 421   {"64", no_argument, NULL, OPTION_64},
 422 #define OPTION_TSO (OPTION_MD_BASE + 5)
 423   {"TSO", no_argument, NULL, OPTION_TSO},
 424 #define OPTION_PSO (OPTION_MD_BASE + 6)
 425   {"PSO", no_argument, NULL, OPTION_PSO},
 426 #define OPTION_RMO (OPTION_MD_BASE + 7)
 427   {"RMO", no_argument, NULL, OPTION_RMO},
 428 #endif
 429 #ifdef SPARC_BIENDIAN
 430 #define OPTION_LITTLE_ENDIAN (OPTION_MD_BASE + 8)
 431   {"EL", no_argument, NULL, OPTION_LITTLE_ENDIAN},
 432 #define OPTION_BIG_ENDIAN (OPTION_MD_BASE + 9)
 433   {"EB", no_argument, NULL, OPTION_BIG_ENDIAN},
 434 #endif
 435 #define OPTION_ENFORCE_ALIGNED_DATA (OPTION_MD_BASE + 10)
 436   {"enforce-aligned-data", no_argument, NULL, OPTION_ENFORCE_ALIGNED_DATA},
 437 #define OPTION_LITTLE_ENDIAN_DATA (OPTION_MD_BASE + 11)
 438   {"little-endian-data", no_argument, NULL, OPTION_LITTLE_ENDIAN_DATA},
 439 #ifdef OBJ_ELF
 440 #define OPTION_NO_UNDECLARED_REGS (OPTION_MD_BASE + 12)
 441   {"no-undeclared-regs", no_argument, NULL, OPTION_NO_UNDECLARED_REGS},
 442 #define OPTION_UNDECLARED_REGS (OPTION_MD_BASE + 13)
 443   {"undeclared-regs", no_argument, NULL, OPTION_UNDECLARED_REGS},
 444 #endif
 445 #define OPTION_RELAX (OPTION_MD_BASE + 14)
 446   {"relax", no_argument, NULL, OPTION_RELAX},
 447 #define OPTION_NO_RELAX (OPTION_MD_BASE + 15)
 448   {"no-relax", no_argument, NULL, OPTION_NO_RELAX},
 449   {NULL, no_argument, NULL, 0}
 450 };
 451
 452 size_t md_longopts_size = sizeof (md_longopts);
 453
 454 int
 455 md_parse_option (c, arg)
 456      int c;
 457      char *arg;
 458 {
 459   /* We don't get a chance to initialize anything before we're called,
 460      so handle that now.  */
 461   if (! default_init_p)
 462     init_default_arch ();
 463
 464   switch (c)
 465     {
 466     case OPTION_BUMP:
 467       warn_on_bump = 1;
 468       warn_after_architecture = SPARC_OPCODE_ARCH_V6;
 469       break;
 470
 471     case OPTION_XARCH:
 472 #ifdef OBJ_ELF
 473       if (strncmp (arg, "v9", 2) != 0)
 474         md_parse_option (OPTION_32, NULL);
 475       else
 476         md_parse_option (OPTION_64, NULL);
 477 #endif
 478       /* Fall through.  */
 479
 480     case 'A':
 481       {
 482         struct sparc_arch *sa;
 483         enum sparc_opcode_arch_val opcode_arch;
 484
 485         sa = lookup_arch (arg);
 486         if (sa == NULL
 487             || ! sa->user_option_p)
 488           {
 489             if (c == OPTION_XARCH)
 490               as_bad (_("invalid architecture -xarch=%s"), arg);
 491             else
 492               as_bad (_("invalid architecture -A%s"), arg);
 493             return 0;
 494           }
 495
 496         opcode_arch = sparc_opcode_lookup_arch (sa->opcode_arch);
 497         if (opcode_arch == SPARC_OPCODE_ARCH_BAD)
 498           as_fatal (_("Bad opcode table, broken assembler."));
 499
 500         max_architecture = opcode_arch;
 501         architecture_requested = 1;
 502       }
 503       break;
 504
 505     case OPTION_SPARC:
 506       /* Ignore -sparc, used by SunOS make default .s.o rule.  */
 507       break;
 508
 509     case OPTION_ENFORCE_ALIGNED_DATA:
 510       enforce_aligned_data = 1;
 511       break;
 512
 513 #ifdef SPARC_BIENDIAN
 514     case OPTION_LITTLE_ENDIAN:
 515       target_big_endian = 0;
 516       if (default_arch_type != sparclet)
 517         as_fatal ("This target does not support -EL");
 518       break;
 519     case OPTION_LITTLE_ENDIAN_DATA:
 520       target_little_endian_data = 1;
 521       target_big_endian = 0;
 522       if (default_arch_type != sparc86x
 523           && default_arch_type != v9)
 524         as_fatal ("This target does not support --little-endian-data");
 525       break;
 526     case OPTION_BIG_ENDIAN:
 527       target_big_endian = 1;
 528       break;
 529 #endif
 530
 531 #ifdef OBJ_AOUT
 532     case 'k':
 533       sparc_pic_code = 1;
 534       break;
 535 #endif
 536
 537 #ifdef OBJ_ELF
 538     case OPTION_32:
 539     case OPTION_64:
 540       {
 541         const char **list, **l;
 542
 543         sparc_arch_size = c == OPTION_32 ? 32 : 64;
 544         list = bfd_target_list ();
 545         for (l = list; *l != NULL; l++)
 546           {
 547             if (sparc_arch_size == 32)
 548               {
 549                 if (strcmp (*l, "elf32-sparc") == 0)
 550                   break;
 551               }
 552             else
 553               {
 554                 if (strcmp (*l, "elf64-sparc") == 0)
 555                   break;
 556               }
 557           }
 558         if (*l == NULL)
 559           as_fatal (_("No compiled in support for %d bit object file format"),
 560                     sparc_arch_size);
 561         free (list);
 562       }
 563       break;
 564
 565     case OPTION_TSO:
 566       sparc_memory_model = MM_TSO;
 567       break;
 568
 569     case OPTION_PSO:
 570       sparc_memory_model = MM_PSO;
 571       break;
 572
 573     case OPTION_RMO:
 574       sparc_memory_model = MM_RMO;
 575       break;
 576
 577     case 'V':
 578       print_version_id ();
 579       break;
 580
 581     case 'Q':
 582       /* Qy - do emit .comment
 583          Qn - do not emit .comment.  */
 584       break;
 585
 586     case 's':
 587       /* Use .stab instead of .stab.excl.  */
 588       break;
 589
 590     case 'q':
 591       /* quick -- Native assembler does fewer checks.  */
 592       break;
 593
 594     case 'K':
 595       if (strcmp (arg, "PIC") != 0)
 596         as_warn (_("Unrecognized option following -K"));
 597       else
 598         sparc_pic_code = 1;
 599       break;
 600
 601     case OPTION_NO_UNDECLARED_REGS:
 602       no_undeclared_regs = 1;
 603       break;
 604
 605     case OPTION_UNDECLARED_REGS:
 606       no_undeclared_regs = 0;
 607       break;
 608 #endif
 609
 610     case OPTION_RELAX:
 611       sparc_relax = 1;
 612       break;
 613
 614     case OPTION_NO_RELAX:
 615       sparc_relax = 0;
 616       break;
 617
 618     default:
 619       return 0;
 620     }
 621
 622   return 1;
 623 }
 624
 625 void
 626 md_show_usage (stream)
 627      FILE *stream;
 628 {
 629   const struct sparc_arch *arch;
 630   int column;
 631
 632   /* We don't get a chance to initialize anything before we're called,
 633      so handle that now.  */
 634   if (! default_init_p)
 635     init_default_arch ();
 636
 637   fprintf (stream, _("SPARC options:\n"));
 638   column = 0;
 639   for (arch = &sparc_arch_table[0]; arch->name; arch++)
 640     {
 641       if (!arch->user_option_p)
 642         continue;
 643       if (arch != &sparc_arch_table[0])
 644         fprintf (stream, " | ");
 645       if (column + strlen (arch->name) > 70)
 646         {
 647           column = 0;
 648           fputc ('\n', stream);
 649         }
 650       column += 5 + 2 + strlen (arch->name);
 651       fprintf (stream, "-A%s", arch->name);
 652     }
 653   for (arch = &sparc_arch_table[0]; arch->name; arch++)
 654     {
 655       if (!arch->user_option_p)
 656         continue;
 657       fprintf (stream, " | ");
 658       if (column + strlen (arch->name) > 65)
 659         {
 660           column = 0;
 661           fputc ('\n', stream);
 662         }
 663       column += 5 + 7 + strlen (arch->name);
 664       fprintf (stream, "-xarch=%s", arch->name);
 665     }
 666   fprintf (stream, _("\n\
 667                         specify variant of SPARC architecture\n\
 668 -bump                   warn when assembler switches architectures\n\
 669 -sparc                  ignored\n\
 670 --enforce-aligned-data  force .long, etc., to be aligned correctly\n\
 671 -relax                  relax jumps and branches (default)\n\
 672 -no-relax               avoid changing any jumps and branches\n"));
 673 #ifdef OBJ_AOUT
 674   fprintf (stream, _("\
 675 -k                      generate PIC\n"));
 676 #endif
 677 #ifdef OBJ_ELF
 678   fprintf (stream, _("\
 679 -32                     create 32 bit object file\n\
 680 -64                     create 64 bit object file\n"));
 681   fprintf (stream, _("\
 682                         [default is %d]\n"), default_arch_size);
 683   fprintf (stream, _("\
 684 -TSO                    use Total Store Ordering\n\
 685 -PSO                    use Partial Store Ordering\n\
 686 -RMO                    use Relaxed Memory Ordering\n"));
 687   fprintf (stream, _("\
 688                         [default is %s]\n"), (default_arch_size == 64) ? "RMO" : "TSO");
 689   fprintf (stream, _("\
 690 -KPIC                   generate PIC\n\
 691 -V                      print assembler version number\n\
 692 -undeclared-regs        ignore application global register usage without\n\
 693                         appropriate .register directive (default)\n\
 694 -no-undeclared-regs     force error on application global register usage\n\
 695                         without appropriate .register directive\n\
 696 -q                      ignored\n\
 697 -Qy, -Qn                ignored\n\
 698 -s                      ignored\n"));
 699 #endif
 700 #ifdef SPARC_BIENDIAN
 701   fprintf (stream, _("\
 702 -EL                     generate code for a little endian machine\n\
 703 -EB                     generate code for a big endian machine\n\
 704 --little-endian-data    generate code for a machine having big endian\n\
 705                         instructions and little endian data.\n"));
 706 #endif
 707 }
 708 \f
 709 /* Native operand size opcode translation.  */
 710 struct
 711   {
 712     char *name;
 713     char *name32;
 714     char *name64;
 715   } native_op_table[] =
 716 {
 717   {"ldn", "ld", "ldx"},
 718   {"ldna", "lda", "ldxa"},
 719   {"stn", "st", "stx"},
 720   {"stna", "sta", "stxa"},
 721   {"slln", "sll", "sllx"},
 722   {"srln", "srl", "srlx"},
 723   {"sran", "sra", "srax"},
 724   {"casn", "cas", "casx"},
 725   {"casna", "casa", "casxa"},
 726   {"clrn", "clr", "clrx"},
 727   {NULL, NULL, NULL},
 728 };
 729 \f
 730 /* sparc64 privileged registers.  */
 731
 732 struct priv_reg_entry
 733 {
 734   char *name;
 735   int regnum;
 736 };
 737
 738 struct priv_reg_entry priv_reg_table[] =
 739 {
 740   {"tpc", 0},
 741   {"tnpc", 1},
 742   {"tstate", 2},
 743   {"tt", 3},
 744   {"tick", 4},
 745   {"tba", 5},
 746   {"pstate", 6},
 747   {"tl", 7},
 748   {"pil", 8},
 749   {"cwp", 9},
 750   {"cansave", 10},
 751   {"canrestore", 11},
 752   {"cleanwin", 12},
 753   {"otherwin", 13},
 754   {"wstate", 14},
 755   {"fq", 15},
 756   {"ver", 31},
 757   {"", -1},                     /* End marker.  */
 758 };
 759
 760 /* v9a specific asrs.  */
 761
 762 struct priv_reg_entry v9a_asr_table[] =
 763 {
 764   {"tick_cmpr", 23},
 765   {"sys_tick_cmpr", 25},
 766   {"sys_tick", 24},
 767   {"softint", 22},
 768   {"set_softint", 20},
 769   {"pic", 17},
 770   {"pcr", 16},
 771   {"gsr", 19},
 772   {"dcr", 18},
 773   {"clear_softint", 21},
 774   {"", -1},                     /* End marker.  */
 775 };
 776
 777 static int
 778 cmp_reg_entry (parg, qarg)
 779      const PTR parg;
 780      const PTR qarg;
 781 {
 782   const struct priv_reg_entry *p = (const struct priv_reg_entry *) parg;
 783   const struct priv_reg_entry *q = (const struct priv_reg_entry *) qarg;
 784
 785   return strcmp (q->name, p->name);
 786 }
 787 \f
 788 /* This function is called once, at assembler startup time.  It should
 789    set up all the tables, etc. that the MD part of the assembler will
 790    need.  */
 791
 792 void
 793 md_begin ()
 794 {
 795   register const char *retval = NULL;
 796   int lose = 0;
 797   register unsigned int i = 0;
 798
 799   /* We don't get a chance to initialize anything before md_parse_option
 800      is called, and it may not be called, so handle default initialization
 801      now if not already done.  */
 802   if (! default_init_p)
 803     init_default_arch ();
 804
 805   sparc_cie_data_alignment = sparc_arch_size == 64 ? -8 : -4;
 806   op_hash = hash_new ();
 807
 808   while (i < (unsigned int) sparc_num_opcodes)
 809     {
 810       const char *name = sparc_opcodes[i].name;
 811       retval = hash_insert (op_hash, name, (PTR) &sparc_opcodes[i]);
 812       if (retval != NULL)
 813         {
 814           as_bad (_("Internal error: can't hash `%s': %s\n"),
 815                   sparc_opcodes[i].name, retval);
 816           lose = 1;
 817         }
 818       do
 819         {
 820           if (sparc_opcodes[i].match & sparc_opcodes[i].lose)
 821             {
 822               as_bad (_("Internal error: losing opcode: `%s' \"%s\"\n"),
 823                       sparc_opcodes[i].name, sparc_opcodes[i].args);
 824               lose = 1;
 825             }
 826           ++i;
 827         }
 828       while (i < (unsigned int) sparc_num_opcodes
 829              && !strcmp (sparc_opcodes[i].name, name));
 830     }
 831
 832   for (i = 0; native_op_table[i].name; i++)
 833     {
 834       const struct sparc_opcode *insn;
 835       char *name = ((sparc_arch_size == 32)
 836                     ? native_op_table[i].name32
 837                     : native_op_table[i].name64);
 838       insn = (struct sparc_opcode *) hash_find (op_hash, name);
 839       if (insn == NULL)
 840         {
 841           as_bad (_("Internal error: can't find opcode `%s' for `%s'\n"),
 842                   name, native_op_table[i].name);
 843           lose = 1;
 844         }
 845       else
 846         {
 847           retval = hash_insert (op_hash, native_op_table[i].name, (PTR) insn);
 848           if (retval != NULL)
 849             {
 850               as_bad (_("Internal error: can't hash `%s': %s\n"),
 851                       sparc_opcodes[i].name, retval);
 852               lose = 1;
 853             }
 854         }
 855     }
 856
 857   if (lose)
 858     as_fatal (_("Broken assembler.  No assembly attempted."));
 859
 860   qsort (priv_reg_table, sizeof (priv_reg_table) / sizeof (priv_reg_table[0]),
 861          sizeof (priv_reg_table[0]), cmp_reg_entry);
 862
 863   /* If -bump, record the architecture level at which we start issuing
 864      warnings.  The behaviour is different depending upon whether an
 865      architecture was explicitly specified.  If it wasn't, we issue warnings
 866      for all upwards bumps.  If it was, we don't start issuing warnings until
 867      we need to bump beyond the requested architecture or when we bump between
 868      conflicting architectures.  */
 869
 870   if (warn_on_bump
 871       && architecture_requested)
 872     {
 873       /* `max_architecture' records the requested architecture.
 874          Issue warnings if we go above it.  */
 875       warn_after_architecture = max_architecture;
 876
 877       /* Find the highest architecture level that doesn't conflict with
 878          the requested one.  */
 879       for (max_architecture = SPARC_OPCODE_ARCH_MAX;
 880            max_architecture > warn_after_architecture;
 881            --max_architecture)
 882         if (! SPARC_OPCODE_CONFLICT_P (max_architecture,
 883                                        warn_after_architecture))
 884           break;
 885     }
 886 }
 887
 888 /* Called after all assembly has been done.  */
 889
 890 void
 891 sparc_md_end ()
 892 {
 893   unsigned long mach = bfd_mach_sparc;
 894
 895   if (sparc_arch_size == 64)
 896     switch (current_architecture)
 897       {
 898       case SPARC_OPCODE_ARCH_V9A: mach = bfd_mach_sparc_v9a; break;
 899       case SPARC_OPCODE_ARCH_V9B: mach = bfd_mach_sparc_v9b; break;
 900       default: mach = bfd_mach_sparc_v9; break;
 901       }
 902   else
 903     switch (current_architecture)
 904       {
 905       case SPARC_OPCODE_ARCH_SPARCLET: mach = bfd_mach_sparc_sparclet; break;
 906       case SPARC_OPCODE_ARCH_V9: mach = bfd_mach_sparc_v8plus; break;
 907       case SPARC_OPCODE_ARCH_V9A: mach = bfd_mach_sparc_v8plusa; break;
 908       case SPARC_OPCODE_ARCH_V9B: mach = bfd_mach_sparc_v8plusb; break;
 909       /* The sparclite is treated like a normal sparc.  Perhaps it shouldn't
 910          be but for now it is (since that's the way it's always been
 911          treated).  */
 912       default: break;
 913       }
 914   bfd_set_arch_mach (stdoutput, bfd_arch_sparc, mach);
 915 }
 916 \f
 917 /* Return non-zero if VAL is in the range -(MAX+1) to MAX.  */
 918
 919 static INLINE int
 920 in_signed_range (val, max)
 921      bfd_signed_vma val, max;
 922 {
 923   if (max <= 0)
 924     abort ();
 925   /* Sign-extend the value from the architecture word size, so that
 926      0xffffffff is always considered -1 on sparc32.  */
 927   if (sparc_arch_size == 32)
 928     {
 929       bfd_signed_vma sign = (bfd_signed_vma) 1 << 31;
 930       val = ((val & U0xffffffff) ^ sign) - sign;
 931     }
 932   if (val > max)
 933     return 0;
 934   if (val < ~max)
 935     return 0;
 936   return 1;
 937 }
 938
 939 /* Return non-zero if VAL is in the range 0 to MAX.  */
 940
 941 static INLINE int
 942 in_unsigned_range (val, max)
 943      bfd_vma val, max;
 944 {
 945   if (val > max)
 946     return 0;
 947   return 1;
 948 }
 949
 950 /* Return non-zero if VAL is in the range -(MAX/2+1) to MAX.
 951    (e.g. -15 to +31).  */
 952
 953 static INLINE int
 954 in_bitfield_range (val, max)
 955      bfd_signed_vma val, max;
 956 {
 957   if (max <= 0)
 958     abort ();
 959   if (val > max)
 960     return 0;
 961   if (val < ~(max >> 1))
 962     return 0;
 963   return 1;
 964 }
 965
 966 static int
 967 sparc_ffs (mask)
 968      unsigned int mask;
 969 {
 970   int i;
 971
 972   if (mask == 0)
 973     return -1;
 974
 975   for (i = 0; (mask & 1) == 0; ++i)
 976     mask >>= 1;
 977   return i;
 978 }
 979
 980 /* Implement big shift right.  */
 981 static bfd_vma
 982 BSR (val, amount)
 983      bfd_vma val;
 984      int amount;
 985 {
 986   if (sizeof (bfd_vma) <= 4 && amount >= 32)
 987     as_fatal (_("Support for 64-bit arithmetic not compiled in."));
 988   return val >> amount;
 989 }
 990 \f
 991 /* For communication between sparc_ip and get_expression.  */
 992 static char *expr_end;
 993
 994 /* Values for `special_case'.
 995    Instructions that require wierd handling because they're longer than
 996    4 bytes.  */
 997 #define SPECIAL_CASE_NONE       0
 998 #define SPECIAL_CASE_SET        1
 999 #define SPECIAL_CASE_SETSW      2
1000 #define SPECIAL_CASE_SETX       3
1001 /* FIXME: sparc-opc.c doesn't have necessary "S" trigger to enable this.  */
1002 #define SPECIAL_CASE_FDIV       4
1003
1004 /* Bit masks of various insns.  */
1005 #define NOP_INSN 0x01000000
1006 #define OR_INSN 0x80100000
1007 #define XOR_INSN 0x80180000
1008 #define FMOVS_INSN 0x81A00020
1009 #define SETHI_INSN 0x01000000
1010 #define SLLX_INSN 0x81281000
1011 #define SRA_INSN 0x81380000
1012
1013 /* The last instruction to be assembled.  */
1014 static const struct sparc_opcode *last_insn;
1015 /* The assembled opcode of `last_insn'.  */
1016 static unsigned long last_opcode;
1017 \f
1018 /* Handle the set and setuw synthetic instructions.  */
1019
1020 static void
1021 synthetize_setuw (insn)
1022      const struct sparc_opcode *insn;
1023 {
1024   int need_hi22_p = 0;
1025   int rd = (the_insn.opcode & RD (~0)) >> 25;
1026
1027   if (the_insn.exp.X_op == O_constant)
1028     {
1029       if (SPARC_OPCODE_ARCH_V9_P (max_architecture))
1030         {
1031           if (sizeof (offsetT) > 4
1032               && (the_insn.exp.X_add_number < 0
1033                   || the_insn.exp.X_add_number > (offsetT) U0xffffffff))
1034             as_warn (_("set: number not in 0..4294967295 range"));
1035         }
1036       else
1037         {
1038           if (sizeof (offsetT) > 4
1039               && (the_insn.exp.X_add_number < -(offsetT) U0x80000000
1040                   || the_insn.exp.X_add_number > (offsetT) U0xffffffff))
1041             as_warn (_("set: number not in -2147483648..4294967295 range"));
1042           the_insn.exp.X_add_number = (int) the_insn.exp.X_add_number;
1043         }
1044     }
1045
1046   /* See if operand is absolute and small; skip sethi if so.  */
1047   if (the_insn.exp.X_op != O_constant
1048       || the_insn.exp.X_add_number >= (1 << 12)
1049       || the_insn.exp.X_add_number < -(1 << 12))
1050     {
1051       the_insn.opcode = (SETHI_INSN | RD (rd)
1052                          | ((the_insn.exp.X_add_number >> 10)
1053                             & (the_insn.exp.X_op == O_constant
1054                                ? 0x3fffff : 0)));
1055       the_insn.reloc = (the_insn.exp.X_op != O_constant
1056                         ? BFD_RELOC_HI22 : BFD_RELOC_NONE);
1057       output_insn (insn, &the_insn);
1058       need_hi22_p = 1;
1059     }
1060
1061   /* See if operand has no low-order bits; skip OR if so.  */
1062   if (the_insn.exp.X_op != O_constant
1063       || (need_hi22_p && (the_insn.exp.X_add_number & 0x3FF) != 0)
1064       || ! need_hi22_p)
1065     {
1066       the_insn.opcode = (OR_INSN | (need_hi22_p ? RS1 (rd) : 0)
1067                          | RD (rd) | IMMED
1068                          | (the_insn.exp.X_add_number
1069                             & (the_insn.exp.X_op != O_constant
1070                                ? 0 : need_hi22_p ? 0x3ff : 0x1fff)));
1071       the_insn.reloc = (the_insn.exp.X_op != O_constant
1072                         ? BFD_RELOC_LO10 : BFD_RELOC_NONE);
1073       output_insn (insn, &the_insn);
1074     }
1075 }
1076
1077 /* Handle the setsw synthetic instruction.  */
1078
1079 static void
1080 synthetize_setsw (insn)
1081      const struct sparc_opcode *insn;
1082 {
1083   int low32, rd, opc;
1084
1085   rd = (the_insn.opcode & RD (~0)) >> 25;
1086
1087   if (the_insn.exp.X_op != O_constant)
1088     {
1089       synthetize_setuw (insn);
1090
1091       /* Need to sign extend it.  */
1092       the_insn.opcode = (SRA_INSN | RS1 (rd) | RD (rd));
1093       the_insn.reloc = BFD_RELOC_NONE;
1094       output_insn (insn, &the_insn);
1095       return;
1096     }
1097
1098   if (sizeof (offsetT) > 4
1099       && (the_insn.exp.X_add_number < -(offsetT) U0x80000000
1100           || the_insn.exp.X_add_number > (offsetT) U0xffffffff))
1101     as_warn (_("setsw: number not in -2147483648..4294967295 range"));
1102
1103   low32 = the_insn.exp.X_add_number;
1104
1105   if (low32 >= 0)
1106     {
1107       synthetize_setuw (insn);
1108       return;
1109     }
1110
1111   opc = OR_INSN;
1112
1113   the_insn.reloc = BFD_RELOC_NONE;
1114   /* See if operand is absolute and small; skip sethi if so.  */
1115   if (low32 < -(1 << 12))
1116     {
1117       the_insn.opcode = (SETHI_INSN | RD (rd)
1118                          | (((~the_insn.exp.X_add_number) >> 10) & 0x3fffff));
1119       output_insn (insn, &the_insn);
1120       low32 = 0x1c00 | (low32 & 0x3ff);
1121       opc = RS1 (rd) | XOR_INSN;
1122     }
1123
1124   the_insn.opcode = (opc | RD (rd) | IMMED
1125                      | (low32 & 0x1fff));
1126   output_insn (insn, &the_insn);
1127 }
1128
1129 /* Handle the setsw synthetic instruction.  */
1130
1131 static void
1132 synthetize_setx (insn)
1133      const struct sparc_opcode *insn;
1134 {
1135   int upper32, lower32;
1136   int tmpreg = (the_insn.opcode & RS1 (~0)) >> 14;
1137   int dstreg = (the_insn.opcode & RD (~0)) >> 25;
1138   int upper_dstreg;
1139   int need_hh22_p = 0, need_hm10_p = 0, need_hi22_p = 0, need_lo10_p = 0;
1140   int need_xor10_p = 0;
1141
1142 #define SIGNEXT32(x) ((((x) & U0xffffffff) ^ U0x80000000) - U0x80000000)
1143   lower32 = SIGNEXT32 (the_insn.exp.X_add_number);
1144   upper32 = SIGNEXT32 (BSR (the_insn.exp.X_add_number, 32));
1145 #undef SIGNEXT32
1146
1147   upper_dstreg = tmpreg;
1148   /* The tmp reg should not be the dst reg.  */
1149   if (tmpreg == dstreg)
1150     as_warn (_("setx: temporary register same as destination register"));
1151
1152   /* ??? Obviously there are other optimizations we can do
1153      (e.g. sethi+shift for 0x1f0000000) and perhaps we shouldn't be
1154      doing some of these.  Later.  If you do change things, try to
1155      change all of this to be table driven as well.  */
1156   /* What to output depends on the number if it's constant.
1157      Compute that first, then output what we've decided upon.  */
1158   if (the_insn.exp.X_op != O_constant)
1159     {
1160       if (sparc_arch_size == 32)
1161         {
1162           /* When arch size is 32, we want setx to be equivalent
1163              to setuw for anything but constants.  */
1164           the_insn.exp.X_add_number &= 0xffffffff;
1165           synthetize_setuw (insn);
1166           return;
1167         }
1168       need_hh22_p = need_hm10_p = need_hi22_p = need_lo10_p = 1;
1169       lower32 = 0;
1170       upper32 = 0;
1171     }
1172   else
1173     {
1174       /* Reset X_add_number, we've extracted it as upper32/lower32.
1175          Otherwise fixup_segment will complain about not being able to
1176          write an 8 byte number in a 4 byte field.  */
1177       the_insn.exp.X_add_number = 0;
1178
1179       /* Only need hh22 if `or' insn can't handle constant.  */
1180       if (upper32 < -(1 << 12) || upper32 >= (1 << 12))
1181         need_hh22_p = 1;
1182
1183       /* Does bottom part (after sethi) have bits?  */
1184       if ((need_hh22_p && (upper32 & 0x3ff) != 0)
1185           /* No hh22, but does upper32 still have bits we can't set
1186              from lower32?  */
1187           || (! need_hh22_p && upper32 != 0 && upper32 != -1))
1188         need_hm10_p = 1;
1189
1190       /* If the lower half is all zero, we build the upper half directly
1191          into the dst reg.  */
1192       if (lower32 != 0
1193           /* Need lower half if number is zero or 0xffffffff00000000.  */
1194           || (! need_hh22_p && ! need_hm10_p))
1195         {
1196           /* No need for sethi if `or' insn can handle constant.  */
1197           if (lower32 < -(1 << 12) || lower32 >= (1 << 12)
1198               /* Note that we can't use a negative constant in the `or'
1199                  insn unless the upper 32 bits are all ones.  */
1200               || (lower32 < 0 && upper32 != -1)
1201               || (lower32 >= 0 && upper32 == -1))
1202             need_hi22_p = 1;
1203
1204           if (need_hi22_p && upper32 == -1)
1205             need_xor10_p = 1;
1206
1207           /* Does bottom part (after sethi) have bits?  */
1208           else if ((need_hi22_p && (lower32 & 0x3ff) != 0)
1209                    /* No sethi.  */
1210                    || (! need_hi22_p && (lower32 & 0x1fff) != 0)
1211                    /* Need `or' if we didn't set anything else.  */
1212                    || (! need_hi22_p && ! need_hh22_p && ! need_hm10_p))
1213             need_lo10_p = 1;
1214         }
1215       else
1216         /* Output directly to dst reg if lower 32 bits are all zero.  */
1217         upper_dstreg = dstreg;
1218     }
1219
1220   if (!upper_dstreg && dstreg)
1221     as_warn (_("setx: illegal temporary register g0"));
1222
1223   if (need_hh22_p)
1224     {
1225       the_insn.opcode = (SETHI_INSN | RD (upper_dstreg)
1226                          | ((upper32 >> 10) & 0x3fffff));
1227       the_insn.reloc = (the_insn.exp.X_op != O_constant
1228                         ? BFD_RELOC_SPARC_HH22 : BFD_RELOC_NONE);
1229       output_insn (insn, &the_insn);
1230     }
1231
1232   if (need_hi22_p)
1233     {
1234       the_insn.opcode = (SETHI_INSN | RD (dstreg)
1235                          | (((need_xor10_p ? ~lower32 : lower32)
1236                              >> 10) & 0x3fffff));
1237       the_insn.reloc = (the_insn.exp.X_op != O_constant
1238                         ? BFD_RELOC_SPARC_LM22 : BFD_RELOC_NONE);
1239       output_insn (insn, &the_insn);
1240     }
1241
1242   if (need_hm10_p)
1243     {
1244       the_insn.opcode = (OR_INSN
1245                          | (need_hh22_p ? RS1 (upper_dstreg) : 0)
1246                          | RD (upper_dstreg)
1247                          | IMMED
1248                          | (upper32 & (need_hh22_p ? 0x3ff : 0x1fff)));
1249       the_insn.reloc = (the_insn.exp.X_op != O_constant
1250                         ? BFD_RELOC_SPARC_HM10 : BFD_RELOC_NONE);
1251       output_insn (insn, &the_insn);
1252     }
1253
1254   if (need_lo10_p)
1255     {
1256       /* FIXME: One nice optimization to do here is to OR the low part
1257          with the highpart if hi22 isn't needed and the low part is
1258          positive.  */
1259       the_insn.opcode = (OR_INSN | (need_hi22_p ? RS1 (dstreg) : 0)
1260                          | RD (dstreg)
1261                          | IMMED
1262                          | (lower32 & (need_hi22_p ? 0x3ff : 0x1fff)));
1263       the_insn.reloc = (the_insn.exp.X_op != O_constant
1264                         ? BFD_RELOC_LO10 : BFD_RELOC_NONE);
1265       output_insn (insn, &the_insn);
1266     }
1267
1268   /* If we needed to build the upper part, shift it into place.  */
1269   if (need_hh22_p || need_hm10_p)
1270     {
1271       the_insn.opcode = (SLLX_INSN | RS1 (upper_dstreg) | RD (upper_dstreg)
1272                          | IMMED | 32);
1273       the_insn.reloc = BFD_RELOC_NONE;
1274       output_insn (insn, &the_insn);
1275     }
1276
1277   /* To get -1 in upper32, we do sethi %hi(~x), r; xor r, -0x400 | x, r.  */
1278   if (need_xor10_p)
1279     {
1280       the_insn.opcode = (XOR_INSN | RS1 (dstreg) | RD (dstreg) | IMMED
1281                          | 0x1c00 | (lower32 & 0x3ff));
1282       the_insn.reloc = BFD_RELOC_NONE;
1283       output_insn (insn, &the_insn);
1284     }
1285
1286   /* If we needed to build both upper and lower parts, OR them together.  */
1287   else if ((need_hh22_p || need_hm10_p) && (need_hi22_p || need_lo10_p))
1288     {
1289       the_insn.opcode = (OR_INSN | RS1 (dstreg) | RS2 (upper_dstreg)
1290                          | RD (dstreg));
1291       the_insn.reloc = BFD_RELOC_NONE;
1292       output_insn (insn, &the_insn);
1293     }
1294 }
1295 \f
1296 /* Main entry point to assemble one instruction.  */
1297
1298 void
1299 md_assemble (str)
1300      char *str;
1301 {
1302   const struct sparc_opcode *insn;
1303   int special_case;
1304
1305   know (str);
1306   special_case = sparc_ip (str, &insn);
1307
1308   /* We warn about attempts to put a floating point branch in a delay slot,
1309      unless the delay slot has been annulled.  */
1310   if (insn != NULL
1311       && last_insn != NULL
1312       && (insn->flags & F_FBR) != 0
1313       && (last_insn->flags & F_DELAYED) != 0
1314       /* ??? This test isn't completely accurate.  We assume anything with
1315          F_{UNBR,CONDBR,FBR} set is annullable.  */
1316       && ((last_insn->flags & (F_UNBR | F_CONDBR | F_FBR)) == 0
1317           || (last_opcode & ANNUL) == 0))
1318     as_warn (_("FP branch in delay slot"));
1319
1320   /* SPARC before v9 requires a nop instruction between a floating
1321      point instruction and a floating point branch.  We insert one
1322      automatically, with a warning.  */
1323   if (max_architecture < SPARC_OPCODE_ARCH_V9
1324       && insn != NULL
1325       && last_insn != NULL
1326       && (insn->flags & F_FBR) != 0
1327       && (last_insn->flags & F_FLOAT) != 0)
1328     {
1329       struct sparc_it nop_insn;
1330
1331       nop_insn.opcode = NOP_INSN;
1332       nop_insn.reloc = BFD_RELOC_NONE;
1333       output_insn (insn, &nop_insn);
1334       as_warn (_("FP branch preceded by FP instruction; NOP inserted"));
1335     }
1336
1337   switch (special_case)
1338     {
1339     case SPECIAL_CASE_NONE:
1340       /* Normal insn.  */
1341       output_insn (insn, &the_insn);
1342       break;
1343
1344     case SPECIAL_CASE_SETSW:
1345       synthetize_setsw (insn);
1346       break;
1347
1348     case SPECIAL_CASE_SET:
1349       synthetize_setuw (insn);
1350       break;
1351
1352     case SPECIAL_CASE_SETX:
1353       synthetize_setx (insn);
1354       break;
1355
1356     case SPECIAL_CASE_FDIV:
1357       {
1358         int rd = (the_insn.opcode >> 25) & 0x1f;
1359
1360         output_insn (insn, &the_insn);
1361
1362         /* According to information leaked from Sun, the "fdiv" instructions
1363            on early SPARC machines would produce incorrect results sometimes.
1364            The workaround is to add an fmovs of the destination register to
1365            itself just after the instruction.  This was true on machines
1366            with Weitek 1165 float chips, such as the Sun-4/260 and /280.  */
1367         assert (the_insn.reloc == BFD_RELOC_NONE);
1368         the_insn.opcode = FMOVS_INSN | rd | RD (rd);
1369         output_insn (insn, &the_insn);
1370         return;
1371       }
1372
1373     default:
1374       as_fatal (_("failed special case insn sanity check"));
1375     }
1376 }
1377
1378 /* Subroutine of md_assemble to do the actual parsing.  */
1379
1380 static int
1381 sparc_ip (str, pinsn)
1382      char *str;
1383      const struct sparc_opcode **pinsn;
1384 {
1385   char *error_message = "";
1386   char *s;
1387   const char *args;
1388   char c;
1389   const struct sparc_opcode *insn;
1390   char *argsStart;
1391   unsigned long opcode;
1392   unsigned int mask = 0;
1393   int match = 0;
1394   int comma = 0;
1395   int v9_arg_p;
1396   int special_case = SPECIAL_CASE_NONE;
1397
1398   s = str;
1399   if (ISLOWER (*s))
1400     {
1401       do
1402         ++s;
1403       while (ISLOWER (*s) || ISDIGIT (*s));
1404     }
1405
1406   switch (*s)
1407     {
1408     case '\0':
1409       break;
1410
1411     case ',':
1412       comma = 1;
1413       /* Fall through.  */
1414
1415     case ' ':
1416       *s++ = '\0';
1417       break;
1418
1419     default:
1420       as_fatal (_("Unknown opcode: `%s'"), str);
1421     }
1422   insn = (struct sparc_opcode *) hash_find (op_hash, str);
1423   *pinsn = insn;
1424   if (insn == NULL)
1425     {
1426       as_bad (_("Unknown opcode: `%s'"), str);
1427       return special_case;
1428     }
1429   if (comma)
1430     {
1431       *--s = ',';
1432     }
1433
1434   argsStart = s;
1435   for (;;)
1436     {
1437       opcode = insn->match;
1438       memset (&the_insn, '\0', sizeof (the_insn));
1439       the_insn.reloc = BFD_RELOC_NONE;
1440       v9_arg_p = 0;
1441
1442       /* Build the opcode, checking as we go to make sure that the
1443          operands match.  */
1444       for (args = insn->args;; ++args)
1445         {
1446           switch (*args)
1447             {
1448             case 'K':
1449               {
1450                 int kmask = 0;
1451
1452                 /* Parse a series of masks.  */
1453                 if (*s == '#')
1454                   {
1455                     while (*s == '#')
1456                       {
1457                         int mask;
1458
1459                         if (! parse_keyword_arg (sparc_encode_membar, &s,
1460                                                  &mask))
1461                           {
1462                             error_message = _(": invalid membar mask name");
1463                             goto error;
1464                           }
1465                         kmask |= mask;
1466                         while (*s == ' ')
1467                           ++s;
1468                         if (*s == '|' || *s == '+')
1469                           ++s;
1470                         while (*s == ' ')
1471                           ++s;
1472                       }
1473                   }
1474                 else
1475                   {
1476                     if (! parse_const_expr_arg (&s, &kmask))
1477                       {
1478                         error_message = _(": invalid membar mask expression");
1479                         goto error;
1480                       }
1481                     if (kmask < 0 || kmask > 127)
1482                       {
1483                         error_message = _(": invalid membar mask number");
1484                         goto error;
1485                       }
1486                   }
1487
1488                 opcode |= MEMBAR (kmask);
1489                 continue;
1490               }
1491
1492             case '3':
1493               {
1494                 int smask = 0;
1495
1496                 if (! parse_const_expr_arg (&s, &smask))
1497                   {
1498                     error_message = _(": invalid siam mode expression");
1499                     goto error;
1500                   }
1501                 if (smask < 0 || smask > 7)
1502                   {
1503                     error_message = _(": invalid siam mode number");
1504                     goto error;
1505                   }
1506                 opcode |= smask;
1507                 continue;
1508               }
1509
1510             case '*':
1511               {
1512                 int fcn = 0;
1513
1514                 /* Parse a prefetch function.  */
1515                 if (*s == '#')
1516                   {
1517                     if (! parse_keyword_arg (sparc_encode_prefetch, &s, &fcn))
1518                       {
1519                         error_message = _(": invalid prefetch function name");
1520                         goto error;
1521                       }
1522                   }
1523                 else
1524                   {
1525                     if (! parse_const_expr_arg (&s, &fcn))
1526                       {
1527                         error_message = _(": invalid prefetch function expression");
1528                         goto error;
1529                       }
1530                     if (fcn < 0 || fcn > 31)
1531                       {
1532                         error_message = _(": invalid prefetch function number");
1533                         goto error;
1534                       }
1535                   }
1536                 opcode |= RD (fcn);
1537                 continue;
1538               }
1539
1540             case '!':
1541             case '?':
1542               /* Parse a sparc64 privileged register.  */
1543               if (*s == '%')
1544                 {
1545                   struct priv_reg_entry *p = priv_reg_table;
1546                   unsigned int len = 9999999; /* Init to make gcc happy.  */
1547
1548                   s += 1;
1549                   while (p->name[0] > s[0])
1550                     p++;
1551                   while (p->name[0] == s[0])
1552                     {
1553                       len = strlen (p->name);
1554                       if (strncmp (p->name, s, len) == 0)
1555                         break;
1556                       p++;
1557                     }
1558                   if (p->name[0] != s[0])
1559                     {
1560                       error_message = _(": unrecognizable privileged register");
1561                       goto error;
1562                     }
1563                   if (*args == '?')
1564                     opcode |= (p->regnum << 14);
1565                   else
1566                     opcode |= (p->regnum << 25);
1567                   s += len;
1568                   continue;
1569                 }
1570               else
1571                 {
1572                   error_message = _(": unrecognizable privileged register");
1573                   goto error;
1574                 }
1575
1576             case '_':
1577             case '/':
1578               /* Parse a v9a/v9b ancillary state register.  */
1579               if (*s == '%')
1580                 {
1581                   struct priv_reg_entry *p = v9a_asr_table;
1582                   unsigned int len = 9999999; /* Init to make gcc happy.  */
1583
1584                   s += 1;
1585                   while (p->name[0] > s[0])
1586                     p++;
1587                   while (p->name[0] == s[0])
1588                     {
1589                       len = strlen (p->name);
1590                       if (strncmp (p->name, s, len) == 0)
1591                         break;
1592                       p++;
1593                     }
1594                   if (p->name[0] != s[0])
1595                     {
1596                       error_message = _(": unrecognizable v9a or v9b ancillary state register");
1597                       goto error;
1598                     }
1599                   if (*args == '/' && (p->regnum == 20 || p->regnum == 21))
1600                     {
1601                       error_message = _(": rd on write only ancillary state register");
1602                       goto error;
1603                     }
1604                   if (p->regnum >= 24
1605                       && (insn->architecture
1606                           & SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9A)))
1607                     {
1608                       /* %sys_tick and %sys_tick_cmpr are v9bnotv9a */
1609                       error_message = _(": unrecognizable v9a ancillary state register");
1610                       goto error;
1611                     }
1612                   if (*args == '/')
1613                     opcode |= (p->regnum << 14);
1614                   else
1615                     opcode |= (p->regnum << 25);
1616                   s += len;
1617                   continue;
1618                 }
1619               else
1620                 {
1621                   error_message = _(": unrecognizable v9a or v9b ancillary state register");
1622                   goto error;
1623                 }
1624
1625             case 'M':
1626             case 'm':
1627               if (strncmp (s, "%asr", 4) == 0)
1628                 {
1629                   s += 4;
1630
1631                   if (ISDIGIT (*s))
1632                     {
1633                       long num = 0;
1634
1635                       while (ISDIGIT (*s))
1636                         {
1637                           num = num * 10 + *s - '0';
1638                           ++s;
1639                         }
1640
1641                       if (current_architecture >= SPARC_OPCODE_ARCH_V9)
1642                         {
1643                           if (num < 16 || 31 < num)
1644                             {
1645                               error_message = _(": asr number must be between 16 and 31");
1646                               goto error;
1647                             }
1648                         }
1649                       else
1650                         {
1651                           if (num < 0 || 31 < num)
1652                             {
1653                               error_message = _(": asr number must be between 0 and 31");
1654                               goto error;
1655                             }
1656                         }
1657
1658                       opcode |= (*args == 'M' ? RS1 (num) : RD (num));
1659                       continue;
1660                     }
1661                   else
1662                     {
1663                       error_message = _(": expecting %asrN");
1664                       goto error;
1665                     }
1666                 } /* if %asr  */
1667               break;
1668
1669             case 'I':
1670               the_insn.reloc = BFD_RELOC_SPARC_11;
1671               goto immediate;
1672
1673             case 'j':
1674               the_insn.reloc = BFD_RELOC_SPARC_10;
1675               goto immediate;
1676
1677             case 'X':
1678               /* V8 systems don't understand BFD_RELOC_SPARC_5.  */
1679               if (SPARC_OPCODE_ARCH_V9_P (max_architecture))
1680                 the_insn.reloc = BFD_RELOC_SPARC_5;
1681               else
1682                 the_insn.reloc = BFD_RELOC_SPARC13;
1683               /* These fields are unsigned, but for upward compatibility,
1684                  allow negative values as well.  */
1685               goto immediate;
1686
1687             case 'Y':
1688               /* V8 systems don't understand BFD_RELOC_SPARC_6.  */
1689               if (SPARC_OPCODE_ARCH_V9_P (max_architecture))
1690                 the_insn.reloc = BFD_RELOC_SPARC_6;
1691               else
1692                 the_insn.reloc = BFD_RELOC_SPARC13;
1693               /* These fields are unsigned, but for upward compatibility,
1694                  allow negative values as well.  */
1695               goto immediate;
1696
1697             case 'k':
1698               the_insn.reloc = /* RELOC_WDISP2_14 */ BFD_RELOC_SPARC_WDISP16;
1699               the_insn.pcrel = 1;
1700               goto immediate;
1701
1702             case 'G':
1703               the_insn.reloc = BFD_RELOC_SPARC_WDISP19;
1704               the_insn.pcrel = 1;
1705               goto immediate;
1706
1707             case 'N':
1708               if (*s == 'p' && s[1] == 'n')
1709                 {
1710                   s += 2;
1711                   continue;
1712                 }
1713               break;
1714
1715             case 'T':
1716               if (*s == 'p' && s[1] == 't')
1717                 {
1718                   s += 2;
1719                   continue;
1720                 }
1721               break;
1722
1723             case 'z':
1724               if (*s == ' ')
1725                 {
1726                   ++s;
1727                 }
1728               if (strncmp (s, "%icc", 4) == 0)
1729                 {
1730                   s += 4;
1731                   continue;
1732                 }
1733               break;
1734
1735             case 'Z':
1736               if (*s == ' ')
1737                 {
1738                   ++s;
1739                 }
1740               if (strncmp (s, "%xcc", 4) == 0)
1741                 {
1742                   s += 4;
1743                   continue;
1744                 }
1745               break;
1746
1747             case '6':
1748               if (*s == ' ')
1749                 {
1750                   ++s;
1751                 }
1752               if (strncmp (s, "%fcc0", 5) == 0)
1753                 {
1754                   s += 5;
1755                   continue;
1756                 }
1757               break;
1758
1759             case '7':
1760               if (*s == ' ')
1761                 {
1762                   ++s;
1763                 }
1764               if (strncmp (s, "%fcc1", 5) == 0)
1765                 {
1766                   s += 5;
1767                   continue;
1768                 }
1769               break;
1770
1771             case '8':
1772               if (*s == ' ')
1773                 {
1774                   ++s;
1775                 }
1776               if (strncmp (s, "%fcc2", 5) == 0)
1777                 {
1778                   s += 5;
1779                   continue;
1780                 }
1781               break;
1782
1783             case '9':
1784               if (*s == ' ')
1785                 {
1786                   ++s;
1787                 }
1788               if (strncmp (s, "%fcc3", 5) == 0)
1789                 {
1790                   s += 5;
1791                   continue;
1792                 }
1793               break;
1794
1795             case 'P':
1796               if (strncmp (s, "%pc", 3) == 0)
1797                 {
1798                   s += 3;
1799                   continue;
1800                 }
1801               break;
1802
1803             case 'W':
1804               if (strncmp (s, "%tick", 5) == 0)
1805                 {
1806                   s += 5;
1807                   continue;
1808                 }
1809               break;
1810
1811             case '\0':          /* End of args.  */
1812               if (s[0] == ',' && s[1] == '%')
1813                 {
1814                   static const struct tls_ops {
1815                     /* The name as it appears in assembler.  */
1816                     char *name;
1817                     /* strlen (name), precomputed for speed */
1818                     int len;
1819                     /* The reloc this pseudo-op translates to.  */
1820                     int reloc;
1821                     /* 1 if call.  */
1822                     int call;
1823                   } tls_ops[] = {
1824                     { "tgd_add", 7, BFD_RELOC_SPARC_TLS_GD_ADD, 0 },
1825                     { "tgd_call", 8, BFD_RELOC_SPARC_TLS_GD_CALL, 1 },
1826                     { "tldm_add", 8, BFD_RELOC_SPARC_TLS_LDM_ADD, 0 },
1827                     { "tldm_call", 9, BFD_RELOC_SPARC_TLS_LDM_CALL, 1 },
1828                     { "tldo_add", 8, BFD_RELOC_SPARC_TLS_LDO_ADD, 0 },
1829                     { "tie_ldx", 7, BFD_RELOC_SPARC_TLS_IE_LDX, 0 },
1830                     { "tie_ld", 6, BFD_RELOC_SPARC_TLS_IE_LD, 0 },
1831                     { "tie_add", 7, BFD_RELOC_SPARC_TLS_IE_ADD, 0 }
1832                   };
1833                   const struct tls_ops *o;
1834                   char *s1;
1835                   int npar = 0;
1836
1837                   for (o = tls_ops; o->name; o++)
1838                     if (strncmp (s + 2, o->name, o->len) == 0)
1839                       break;
1840                   if (o->name == NULL)
1841                     break;
1842
1843                   if (s[o->len + 2] != '(')
1844                     {
1845                       as_bad (_("Illegal operands: %%%s requires arguments in ()"), o->name);
1846                       return special_case;
1847                     }
1848
1849                   if (! o->call && the_insn.reloc != BFD_RELOC_NONE)
1850                     {
1851                       as_bad (_("Illegal operands: %%%s cannot be used together with other relocs in the insn ()"),
1852                               o->name);
1853                       return special_case;
1854                     }
1855
1856                   if (o->call
1857                       && (the_insn.reloc != BFD_RELOC_32_PCREL_S2
1858                           || the_insn.exp.X_add_number != 0
1859                           || the_insn.exp.X_add_symbol
1860                              != symbol_find_or_make ("__tls_get_addr")))
1861                     {
1862                       as_bad (_("Illegal operands: %%%s can be only used with call __tls_get_addr"),
1863                               o->name);
1864                       return special_case;
1865                     }
1866
1867                   the_insn.reloc = o->reloc;
1868                   memset (&the_insn.exp, 0, sizeof (the_insn.exp));
1869                   s += o->len + 3;
1870
1871                   for (s1 = s; *s1 && *s1 != ',' && *s1 != ']'; s1++)
1872                     if (*s1 == '(')
1873                       npar++;
1874                     else if (*s1 == ')')
1875                       {
1876                         if (!npar)
1877                           break;
1878                         npar--;
1879                       }
1880
1881                   if (*s1 != ')')
1882                     {
1883                       as_bad (_("Illegal operands: %%%s requires arguments in ()"), o->name);
1884                       return special_case;
1885                     }
1886
1887                   *s1 = '\0';
1888                   (void) get_expression (s);
1889                   *s1 = ')';
1890                   s = s1 + 1;
1891                 }
1892               if (*s == '\0')
1893                 match = 1;
1894               break;
1895
1896             case '+':
1897               if (*s == '+')
1898                 {
1899                   ++s;
1900                   continue;
1901                 }
1902               if (*s == '-')
1903                 {
1904                   continue;
1905                 }
1906               break;
1907
1908             case '[':           /* These must match exactly.  */
1909             case ']':
1910             case ',':
1911             case ' ':
1912               if (*s++ == *args)
1913                 continue;
1914               break;
1915
1916             case '#':           /* Must be at least one digit.  */
1917               if (ISDIGIT (*s++))
1918                 {
1919                   while (ISDIGIT (*s))
1920                     {
1921                       ++s;
1922                     }
1923                   continue;
1924                 }
1925               break;
1926
1927             case 'C':           /* Coprocessor state register.  */
1928               if (strncmp (s, "%csr", 4) == 0)
1929                 {
1930                   s += 4;
1931                   continue;
1932                 }
1933               break;
1934
1935             case 'b':           /* Next operand is a coprocessor register.  */
1936             case 'c':
1937             case 'D':
1938               if (*s++ == '%' && *s++ == 'c' && ISDIGIT (*s))
1939                 {
1940                   mask = *s++;
1941                   if (ISDIGIT (*s))
1942                     {
1943                       mask = 10 * (mask - '0') + (*s++ - '0');
1944                       if (mask >= 32)
1945                         {
1946                           break;
1947                         }
1948                     }
1949                   else
1950                     {
1951                       mask -= '0';
1952                     }
1953                   switch (*args)
1954                     {
1955
1956                     case 'b':
1957                       opcode |= mask << 14;
1958                       continue;
1959
1960                     case 'c':
1961                       opcode |= mask;
1962                       continue;
1963
1964                     case 'D':
1965                       opcode |= mask << 25;
1966                       continue;
1967                     }
1968                 }
1969               break;
1970
1971             case 'r':           /* next operand must be a register */
1972             case 'O':
1973             case '1':
1974             case '2':
1975             case 'd':
1976               if (*s++ == '%')
1977                 {
1978                   switch (c = *s++)
1979                     {
1980
1981                     case 'f':   /* frame pointer */
1982                       if (*s++ == 'p')
1983                         {
1984                           mask = 0x1e;
1985                           break;
1986                         }
1987                       goto error;
1988
1989                     case 'g':   /* global register */
1990                       c = *s++;
1991                       if (isoctal (c))
1992                         {
1993                           mask = c - '0';
1994                           break;
1995                         }
1996                       goto error;
1997
1998                     case 'i':   /* in register */
1999                       c = *s++;
2000                       if (isoctal (c))
2001                         {
2002                           mask = c - '0' + 24;
2003                           break;
2004                         }
2005                       goto error;
2006
2007                     case 'l':   /* local register */
2008                       c = *s++;
2009                       if (isoctal (c))
2010                         {
2011                           mask = (c - '0' + 16);
2012                           break;
2013                         }
2014                       goto error;
2015
2016                     case 'o':   /* out register */
2017                       c = *s++;
2018                       if (isoctal (c))
2019                         {
2020                           mask = (c - '0' + 8);
2021                           break;
2022                         }
2023                       goto error;
2024
2025                     case 's':   /* stack pointer */
2026                       if (*s++ == 'p')
2027                         {
2028                           mask = 0xe;
2029                           break;
2030                         }
2031                       goto error;
2032
2033                     case 'r':   /* any register */
2034                       if (!ISDIGIT ((c = *s++)))
2035                         {
2036                           goto error;
2037                         }
2038                       /* FALLTHROUGH */
2039                     case '0':
2040                     case '1':
2041                     case '2':
2042                     case '3':
2043                     case '4':
2044                     case '5':
2045                     case '6':
2046                     case '7':
2047                     case '8':
2048                     case '9':
2049                       if (ISDIGIT (*s))
2050                         {
2051                           if ((c = 10 * (c - '0') + (*s++ - '0')) >= 32)
2052                             {
2053                               goto error;
2054                             }
2055                         }
2056                       else
2057                         {
2058                           c -= '0';
2059                         }
2060                       mask = c;
2061                       break;
2062
2063                     default:
2064                       goto error;
2065                     }
2066
2067                   if ((mask & ~1) == 2 && sparc_arch_size == 64
2068                       && no_undeclared_regs && ! globals[mask])
2069                     as_bad (_("detected global register use not covered by .register pseudo-op"));
2070
2071                   /* Got the register, now figure out where
2072                      it goes in the opcode.  */
2073                   switch (*args)
2074                     {
2075                     case '1':
2076                       opcode |= mask << 14;
2077                       continue;
2078
2079                     case '2':
2080                       opcode |= mask;
2081                       continue;
2082
2083                     case 'd':
2084                       opcode |= mask << 25;
2085                       continue;
2086
2087                     case 'r':
2088                       opcode |= (mask << 25) | (mask << 14);
2089                       continue;
2090
2091                     case 'O':
2092                       opcode |= (mask << 25) | (mask << 0);
2093                       continue;
2094                     }
2095                 }
2096               break;
2097
2098             case 'e':           /* next operand is a floating point register */
2099             case 'v':
2100             case 'V':
2101
2102             case 'f':
2103             case 'B':
2104             case 'R':
2105
2106             case 'g':
2107             case 'H':
2108             case 'J':
2109               {
2110                 char format;
2111
2112                 if (*s++ == '%'
2113                     && ((format = *s) == 'f')
2114                     && ISDIGIT (*++s))
2115                   {
2116                     for (mask = 0; ISDIGIT (*s); ++s)
2117                       {
2118                         mask = 10 * mask + (*s - '0');
2119                       }         /* read the number */
2120
2121                     if ((*args == 'v'
2122                          || *args == 'B'
2123                          || *args == 'H')
2124                         && (mask & 1))
2125                       {
2126                         break;
2127                       }         /* register must be even numbered */
2128
2129                     if ((*args == 'V'
2130                          || *args == 'R'
2131                          || *args == 'J')
2132                         && (mask & 3))
2133                       {
2134                         break;
2135                       }         /* register must be multiple of 4 */
2136
2137                     if (mask >= 64)
2138                       {
2139                         if (SPARC_OPCODE_ARCH_V9_P (max_architecture))
2140                           error_message = _(": There are only 64 f registers; [0-63]");
2141                         else
2142                           error_message = _(": There are only 32 f registers; [0-31]");
2143                         goto error;
2144                       } /* on error */
2145                     else if (mask >= 32)
2146                       {
2147                         if (SPARC_OPCODE_ARCH_V9_P (max_architecture))
2148                           {
2149                             v9_arg_p = 1;
2150                             mask -= 31; /* wrap high bit */
2151                           }
2152                         else
2153                           {
2154                             error_message = _(": There are only 32 f registers; [0-31]");
2155                             goto error;
2156                           }
2157                       }
2158                   }
2159                 else
2160                   {
2161                     break;
2162                   }     /* if not an 'f' register.  */
2163
2164                 switch (*args)
2165                   {
2166                   case 'v':
2167                   case 'V':
2168                   case 'e':
2169                     opcode |= RS1 (mask);
2170                     continue;
2171
2172                   case 'f':
2173                   case 'B':
2174                   case 'R':
2175                     opcode |= RS2 (mask);
2176                     continue;
2177
2178                   case 'g':
2179                   case 'H':
2180                   case 'J':
2181                     opcode |= RD (mask);
2182                     continue;
2183                   }             /* Pack it in.  */
2184
2185                 know (0);
2186                 break;
2187               }                 /* float arg  */
2188
2189             case 'F':
2190               if (strncmp (s, "%fsr", 4) == 0)
2191                 {
2192                   s += 4;
2193                   continue;
2194                 }
2195               break;
2196
2197             case '0':           /* 64 bit immediate (set, setsw, setx insn)  */
2198               the_insn.reloc = BFD_RELOC_NONE; /* reloc handled elsewhere  */
2199               goto immediate;
2200
2201             case 'l':           /* 22 bit PC relative immediate  */
2202               the_insn.reloc = BFD_RELOC_SPARC_WDISP22;
2203               the_insn.pcrel = 1;
2204               goto immediate;
2205
2206             case 'L':           /* 30 bit immediate  */
2207               the_insn.reloc = BFD_RELOC_32_PCREL_S2;
2208               the_insn.pcrel = 1;
2209               goto immediate;
2210
2211             case 'h':
2212             case 'n':           /* 22 bit immediate  */
2213               the_insn.reloc = BFD_RELOC_SPARC22;
2214               goto immediate;
2215
2216             case 'i':           /* 13 bit immediate  */
2217               the_insn.reloc = BFD_RELOC_SPARC13;
2218
2219               /* fallthrough */
2220
2221             immediate:
2222               if (*s == ' ')
2223                 s++;
2224
2225               {
2226                 char *s1;
2227                 char *op_arg = NULL;
2228                 expressionS op_exp;
2229                 bfd_reloc_code_real_type old_reloc = the_insn.reloc;
2230
2231                 /* Check for %hi, etc.  */
2232                 if (*s == '%')
2233                   {
2234                     static const struct ops {
2235                       /* The name as it appears in assembler.  */
2236                       char *name;
2237                       /* strlen (name), precomputed for speed */
2238                       int len;
2239                       /* The reloc this pseudo-op translates to.  */
2240                       int reloc;
2241                       /* Non-zero if for v9 only.  */
2242                       int v9_p;
2243                       /* Non-zero if can be used in pc-relative contexts.  */
2244                       int pcrel_p;/*FIXME:wip*/
2245                     } ops[] = {
2246                       /* hix/lox must appear before hi/lo so %hix won't be
2247                          mistaken for %hi.  */
2248                       { "hix", 3, BFD_RELOC_SPARC_HIX22, 1, 0 },
2249                       { "lox", 3, BFD_RELOC_SPARC_LOX10, 1, 0 },
2250                       { "hi", 2, BFD_RELOC_HI22, 0, 1 },
2251                       { "lo", 2, BFD_RELOC_LO10, 0, 1 },
2252                       { "hh", 2, BFD_RELOC_SPARC_HH22, 1, 1 },
2253                       { "hm", 2, BFD_RELOC_SPARC_HM10, 1, 1 },
2254                       { "lm", 2, BFD_RELOC_SPARC_LM22, 1, 1 },
2255                       { "h44", 3, BFD_RELOC_SPARC_H44, 1, 0 },
2256                       { "m44", 3, BFD_RELOC_SPARC_M44, 1, 0 },
2257                       { "l44", 3, BFD_RELOC_SPARC_L44, 1, 0 },
2258                       { "uhi", 3, BFD_RELOC_SPARC_HH22, 1, 0 },
2259                       { "ulo", 3, BFD_RELOC_SPARC_HM10, 1, 0 },
2260                       { "tgd_hi22", 8, BFD_RELOC_SPARC_TLS_GD_HI22, 0, 0 },
2261                       { "tgd_lo10", 8, BFD_RELOC_SPARC_TLS_GD_LO10, 0, 0 },
2262                       { "tldm_hi22", 9, BFD_RELOC_SPARC_TLS_LDM_HI22, 0, 0 },
2263                       { "tldm_lo10", 9, BFD_RELOC_SPARC_TLS_LDM_LO10, 0, 0 },
2264                       { "tldo_hix22", 10, BFD_RELOC_SPARC_TLS_LDO_HIX22, 0,
2265                                                                          0 },
2266                       { "tldo_lox10", 10, BFD_RELOC_SPARC_TLS_LDO_LOX10, 0,
2267                                                                          0 },
2268                       { "tie_hi22", 8, BFD_RELOC_SPARC_TLS_IE_HI22, 0, 0 },
2269                       { "tie_lo10", 8, BFD_RELOC_SPARC_TLS_IE_LO10, 0, 0 },
2270                       { "tle_hix22", 9, BFD_RELOC_SPARC_TLS_LE_HIX22, 0, 0 },
2271                       { "tle_lox10", 9, BFD_RELOC_SPARC_TLS_LE_LOX10, 0, 0 },
2272                       { NULL, 0, 0, 0, 0 }
2273                     };
2274                     const struct ops *o;
2275
2276                     for (o = ops; o->name; o++)
2277                       if (strncmp (s + 1, o->name, o->len) == 0)
2278                         break;
2279                     if (o->name == NULL)
2280                       break;
2281
2282                     if (s[o->len + 1] != '(')
2283                       {
2284                         as_bad (_("Illegal operands: %%%s requires arguments in ()"), o->name);
2285                         return special_case;
2286                       }
2287
2288                     op_arg = o->name;
2289                     the_insn.reloc = o->reloc;
2290                     s += o->len + 2;
2291                     v9_arg_p = o->v9_p;
2292                   }
2293
2294                 /* Note that if the get_expression() fails, we will still
2295                    have created U entries in the symbol table for the
2296                    'symbols' in the input string.  Try not to create U
2297                    symbols for registers, etc.  */
2298
2299                 /* This stuff checks to see if the expression ends in
2300                    +%reg.  If it does, it removes the register from
2301                    the expression, and re-sets 's' to point to the
2302                    right place.  */
2303
2304                 if (op_arg)
2305                   {
2306                     int npar = 0;
2307
2308                     for (s1 = s; *s1 && *s1 != ',' && *s1 != ']'; s1++)
2309                       if (*s1 == '(')
2310                         npar++;
2311                       else if (*s1 == ')')
2312                         {
2313                           if (!npar)
2314                             break;
2315                           npar--;
2316                         }
2317
2318                     if (*s1 != ')')
2319                       {
2320                         as_bad (_("Illegal operands: %%%s requires arguments in ()"), op_arg);
2321                         return special_case;
2322                       }
2323
2324                     *s1 = '\0';
2325                     (void) get_expression (s);
2326                     *s1 = ')';
2327                     s = s1 + 1;
2328                     if (*s == ',' || *s == ']' || !*s)
2329                       continue;
2330                     if (*s != '+' && *s != '-')
2331                       {
2332                         as_bad (_("Illegal operands: Can't do arithmetics other than + and - involving %%%s()"), op_arg);
2333                         return special_case;
2334                       }
2335                     *s1 = '0';
2336                     s = s1;
2337                     op_exp = the_insn.exp;
2338                     memset (&the_insn.exp, 0, sizeof (the_insn.exp));
2339                   }
2340
2341                 for (s1 = s; *s1 && *s1 != ',' && *s1 != ']'; s1++)
2342                   ;
2343
2344                 if (s1 != s && ISDIGIT (s1[-1]))
2345                   {
2346                     if (s1[-2] == '%' && s1[-3] == '+')
2347                       s1 -= 3;
2348                     else if (strchr ("goli0123456789", s1[-2]) && s1[-3] == '%' && s1[-4] == '+')
2349                       s1 -= 4;
2350                     else
2351                       s1 = NULL;
2352                     if (s1)
2353                       {
2354                         *s1 = '\0';
2355                         if (op_arg && s1 == s + 1)
2356                           the_insn.exp.X_op = O_absent;
2357                         else
2358                           (void) get_expression (s);
2359                         *s1 = '+';
2360                         if (op_arg)
2361                           *s = ')';
2362                         s = s1;
2363                       }
2364                   }
2365                 else
2366                   s1 = NULL;
2367
2368                 if (!s1)
2369                   {
2370                     (void) get_expression (s);
2371                     if (op_arg)
2372                       *s = ')';
2373                     s = expr_end;
2374                   }
2375
2376                 if (op_arg)
2377                   {
2378                     the_insn.exp2 = the_insn.exp;
2379                     the_insn.exp = op_exp;
2380                     if (the_insn.exp2.X_op == O_absent)
2381                       the_insn.exp2.X_op = O_illegal;
2382                     else if (the_insn.exp.X_op == O_absent)
2383                       {
2384                         the_insn.exp = the_insn.exp2;
2385                         the_insn.exp2.X_op = O_illegal;
2386                       }
2387                     else if (the_insn.exp.X_op == O_constant)
2388                       {
2389                         valueT val = the_insn.exp.X_add_number;
2390                         switch (the_insn.reloc)
2391                           {
2392                           default:
2393                             break;
2394
2395                           case BFD_RELOC_SPARC_HH22:
2396                             val = BSR (val, 32);
2397                             /* Fall through.  */
2398
2399                           case BFD_RELOC_SPARC_LM22:
2400                           case BFD_RELOC_HI22:
2401                             val = (val >> 10) & 0x3fffff;
2402                             break;
2403
2404                           case BFD_RELOC_SPARC_HM10:
2405                             val = BSR (val, 32);
2406                             /* Fall through.  */
2407
2408                           case BFD_RELOC_LO10:
2409                             val &= 0x3ff;
2410                             break;
2411
2412                           case BFD_RELOC_SPARC_H44:
2413                             val >>= 22;
2414                             val &= 0x3fffff;
2415                             break;
2416
2417                           case BFD_RELOC_SPARC_M44:
2418                             val >>= 12;
2419                             val &= 0x3ff;
2420                             break;
2421
2422                           case BFD_RELOC_SPARC_L44:
2423                             val &= 0xfff;
2424                             break;
2425
2426                           case BFD_RELOC_SPARC_HIX22:
2427                             val = ~val;
2428                             val = (val >> 10) & 0x3fffff;
2429                             break;
2430
2431                           case BFD_RELOC_SPARC_LOX10:
2432                             val = (val & 0x3ff) | 0x1c00;
2433                             break;
2434                           }
2435                         the_insn.exp = the_insn.exp2;
2436                         the_insn.exp.X_add_number += val;
2437                         the_insn.exp2.X_op = O_illegal;
2438                         the_insn.reloc = old_reloc;
2439                       }
2440                     else if (the_insn.exp2.X_op != O_constant)
2441                       {
2442                         as_bad (_("Illegal operands: Can't add non-constant expression to %%%s()"), op_arg);
2443                         return special_case;
2444                       }
2445                     else
2446                       {
2447                         if (old_reloc != BFD_RELOC_SPARC13
2448                             || the_insn.reloc != BFD_RELOC_LO10
2449                             || sparc_arch_size != 64
2450                             || sparc_pic_code)
2451                           {
2452                             as_bad (_("Illegal operands: Can't do arithmetics involving %%%s() of a relocatable symbol"), op_arg);
2453                             return special_case;
2454                           }
2455                         the_insn.reloc = BFD_RELOC_SPARC_OLO10;
2456                       }
2457                   }
2458               }
2459               /* Check for constants that don't require emitting a reloc.  */
2460               if (the_insn.exp.X_op == O_constant
2461                   && the_insn.exp.X_add_symbol == 0
2462                   && the_insn.exp.X_op_symbol == 0)
2463                 {
2464                   /* For pc-relative call instructions, we reject
2465                      constants to get better code.  */
2466                   if (the_insn.pcrel
2467                       && the_insn.reloc == BFD_RELOC_32_PCREL_S2
2468                       && in_signed_range (the_insn.exp.X_add_number, 0x3fff))
2469                     {
2470                       error_message = _(": PC-relative operand can't be a constant");
2471                       goto error;
2472                     }
2473
2474                   if (the_insn.reloc >= BFD_RELOC_SPARC_TLS_GD_HI22
2475                       && the_insn.reloc <= BFD_RELOC_SPARC_TLS_TPOFF64)
2476                     {
2477                       error_message = _(": TLS operand can't be a constant");
2478                       goto error;
2479                     }
2480
2481                   /* Constants that won't fit are checked in md_apply_fix3
2482                      and bfd_install_relocation.
2483                      ??? It would be preferable to install the constants
2484                      into the insn here and save having to create a fixS
2485                      for each one.  There already exists code to handle
2486                      all the various cases (e.g. in md_apply_fix3 and
2487                      bfd_install_relocation) so duplicating all that code
2488                      here isn't right.  */
2489                 }
2490
2491               continue;
2492
2493             case 'a':
2494               if (*s++ == 'a')
2495                 {
2496                   opcode |= ANNUL;
2497                   continue;
2498                 }
2499               break;
2500
2501             case 'A':
2502               {
2503                 int asi = 0;
2504
2505                 /* Parse an asi.  */
2506                 if (*s == '#')
2507                   {
2508                     if (! parse_keyword_arg (sparc_encode_asi, &s, &asi))
2509                       {
2510                         error_message = _(": invalid ASI name");
2511                         goto error;
2512                       }
2513                   }
2514                 else
2515                   {
2516                     if (! parse_const_expr_arg (&s, &asi))
2517                       {
2518                         error_message = _(": invalid ASI expression");
2519                         goto error;
2520                       }
2521                     if (asi < 0 || asi > 255)
2522                       {
2523                         error_message = _(": invalid ASI number");
2524                         goto error;
2525                       }
2526                   }
2527                 opcode |= ASI (asi);
2528                 continue;
2529               }                 /* Alternate space.  */
2530
2531             case 'p':
2532               if (strncmp (s, "%psr", 4) == 0)
2533                 {
2534                   s += 4;
2535                   continue;
2536                 }
2537               break;
2538
2539             case 'q':           /* Floating point queue.  */
2540               if (strncmp (s, "%fq", 3) == 0)
2541                 {
2542                   s += 3;
2543                   continue;
2544                 }
2545               break;
2546
2547             case 'Q':           /* Coprocessor queue.  */
2548               if (strncmp (s, "%cq", 3) == 0)
2549                 {
2550                   s += 3;
2551                   continue;
2552                 }
2553               break;
2554
2555             case 'S':
2556               if (strcmp (str, "set") == 0
2557                   || strcmp (str, "setuw") == 0)
2558                 {
2559                   special_case = SPECIAL_CASE_SET;
2560                   continue;
2561                 }
2562               else if (strcmp (str, "setsw") == 0)
2563                 {
2564                   special_case = SPECIAL_CASE_SETSW;
2565                   continue;
2566                 }
2567               else if (strcmp (str, "setx") == 0)
2568                 {
2569                   special_case = SPECIAL_CASE_SETX;
2570                   continue;
2571                 }
2572               else if (strncmp (str, "fdiv", 4) == 0)
2573                 {
2574                   special_case = SPECIAL_CASE_FDIV;
2575                   continue;
2576                 }
2577               break;
2578
2579             case 'o':
2580               if (strncmp (s, "%asi", 4) != 0)
2581                 break;
2582               s += 4;
2583               continue;
2584
2585             case 's':
2586               if (strncmp (s, "%fprs", 5) != 0)
2587                 break;
2588               s += 5;
2589               continue;
2590
2591             case 'E':
2592               if (strncmp (s, "%ccr", 4) != 0)
2593                 break;
2594               s += 4;
2595               continue;
2596
2597             case 't':
2598               if (strncmp (s, "%tbr", 4) != 0)
2599                 break;
2600               s += 4;
2601               continue;
2602
2603             case 'w':
2604               if (strncmp (s, "%wim", 4) != 0)
2605                 break;
2606               s += 4;
2607               continue;
2608
2609             case 'x':
2610               {
2611                 char *push = input_line_pointer;
2612                 expressionS e;
2613
2614                 input_line_pointer = s;
2615                 expression (&e);
2616                 if (e.X_op == O_constant)
2617                   {
2618                     int n = e.X_add_number;
2619                     if (n != e.X_add_number || (n & ~0x1ff) != 0)
2620                       as_bad (_("OPF immediate operand out of range (0-0x1ff)"));
2621                     else
2622                       opcode |= e.X_add_number << 5;
2623                   }
2624                 else
2625                   as_bad (_("non-immediate OPF operand, ignored"));
2626                 s = input_line_pointer;
2627                 input_line_pointer = push;
2628                 continue;
2629               }
2630
2631             case 'y':
2632               if (strncmp (s, "%y", 2) != 0)
2633                 break;
2634               s += 2;
2635               continue;
2636
2637             case 'u':
2638             case 'U':
2639               {
2640                 /* Parse a sparclet cpreg.  */
2641                 int cpreg;
2642                 if (! parse_keyword_arg (sparc_encode_sparclet_cpreg, &s, &cpreg))
2643                   {
2644                     error_message = _(": invalid cpreg name");
2645                     goto error;
2646                   }
2647                 opcode |= (*args == 'U' ? RS1 (cpreg) : RD (cpreg));
2648                 continue;
2649               }
2650
2651             default:
2652               as_fatal (_("failed sanity check."));
2653             }                   /* switch on arg code.  */
2654
2655           /* Break out of for() loop.  */
2656           break;
2657         }                       /* For each arg that we expect.  */
2658
2659     error:
2660       if (match == 0)
2661         {
2662           /* Args don't match.  */
2663           if (&insn[1] - sparc_opcodes < sparc_num_opcodes
2664               && (insn->name == insn[1].name
2665                   || !strcmp (insn->name, insn[1].name)))
2666             {
2667               ++insn;
2668               s = argsStart;
2669               continue;
2670             }
2671           else
2672             {
2673               as_bad (_("Illegal operands%s"), error_message);
2674               return special_case;
2675             }
2676         }
2677       else
2678         {
2679           /* We have a match.  Now see if the architecture is OK.  */
2680           int needed_arch_mask = insn->architecture;
2681
2682           if (v9_arg_p)
2683             {
2684               needed_arch_mask &=
2685                 ~(SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9) - 1);
2686               if (! needed_arch_mask)
2687                 needed_arch_mask =
2688                   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9);
2689             }
2690
2691           if (needed_arch_mask
2692               & SPARC_OPCODE_SUPPORTED (current_architecture))
2693             /* OK.  */
2694             ;
2695           /* Can we bump up the architecture?  */
2696           else if (needed_arch_mask
2697                    & SPARC_OPCODE_SUPPORTED (max_architecture))
2698             {
2699               enum sparc_opcode_arch_val needed_architecture =
2700                 sparc_ffs (SPARC_OPCODE_SUPPORTED (max_architecture)
2701                            & needed_arch_mask);
2702
2703               assert (needed_architecture <= SPARC_OPCODE_ARCH_MAX);
2704               if (warn_on_bump
2705                   && needed_architecture > warn_after_architecture)
2706                 {
2707                   as_warn (_("architecture bumped from \"%s\" to \"%s\" on \"%s\""),
2708                            sparc_opcode_archs[current_architecture].name,
2709                            sparc_opcode_archs[needed_architecture].name,
2710                            str);
2711                   warn_after_architecture = needed_architecture;
2712                 }
2713               current_architecture = needed_architecture;
2714             }
2715           /* Conflict.  */
2716           /* ??? This seems to be a bit fragile.  What if the next entry in
2717              the opcode table is the one we want and it is supported?
2718              It is possible to arrange the table today so that this can't
2719              happen but what about tomorrow?  */
2720           else
2721             {
2722               int arch, printed_one_p = 0;
2723               char *p;
2724               char required_archs[SPARC_OPCODE_ARCH_MAX * 16];
2725
2726               /* Create a list of the architectures that support the insn.  */
2727               needed_arch_mask &= ~SPARC_OPCODE_SUPPORTED (max_architecture);
2728               p = required_archs;
2729               arch = sparc_ffs (needed_arch_mask);
2730               while ((1 << arch) <= needed_arch_mask)
2731                 {
2732                   if ((1 << arch) & needed_arch_mask)
2733                     {
2734                       if (printed_one_p)
2735                         *p++ = '|';
2736                       strcpy (p, sparc_opcode_archs[arch].name);
2737                       p += strlen (p);
2738                       printed_one_p = 1;
2739                     }
2740                   ++arch;
2741                 }
2742
2743               as_bad (_("Architecture mismatch on \"%s\"."), str);
2744               as_tsktsk (_(" (Requires %s; requested architecture is %s.)"),
2745                          required_archs,
2746                          sparc_opcode_archs[max_architecture].name);
2747               return special_case;
2748             }
2749         } /* If no match.  */
2750
2751       break;
2752     } /* Forever looking for a match.  */
2753
2754   the_insn.opcode = opcode;
2755   return special_case;
2756 }
2757
2758 /* Parse an argument that can be expressed as a keyword.
2759    (eg: #StoreStore or %ccfr).
2760    The result is a boolean indicating success.
2761    If successful, INPUT_POINTER is updated.  */
2762
2763 static int
2764 parse_keyword_arg (lookup_fn, input_pointerP, valueP)
2765      int (*lookup_fn) PARAMS ((const char *));
2766      char **input_pointerP;
2767      int *valueP;
2768 {
2769   int value;
2770   char c, *p, *q;
2771
2772   p = *input_pointerP;
2773   for (q = p + (*p == '#' || *p == '%');
2774        ISALNUM (*q) || *q == '_';
2775        ++q)
2776     continue;
2777   c = *q;
2778   *q = 0;
2779   value = (*lookup_fn) (p);
2780   *q = c;
2781   if (value == -1)
2782     return 0;
2783   *valueP = value;
2784   *input_pointerP = q;
2785   return 1;
2786 }
2787
2788 /* Parse an argument that is a constant expression.
2789    The result is a boolean indicating success.  */
2790
2791 static int
2792 parse_const_expr_arg (input_pointerP, valueP)
2793      char **input_pointerP;
2794      int *valueP;
2795 {
2796   char *save = input_line_pointer;
2797   expressionS exp;
2798
2799   input_line_pointer = *input_pointerP;
2800   /* The next expression may be something other than a constant
2801      (say if we're not processing the right variant of the insn).
2802      Don't call expression unless we're sure it will succeed as it will
2803      signal an error (which we want to defer until later).  */
2804   /* FIXME: It might be better to define md_operand and have it recognize
2805      things like %asi, etc. but continuing that route through to the end
2806      is a lot of work.  */
2807   if (*input_line_pointer == '%')
2808     {
2809       input_line_pointer = save;
2810       return 0;
2811     }
2812   expression (&exp);
2813   *input_pointerP = input_line_pointer;
2814   input_line_pointer = save;
2815   if (exp.X_op != O_constant)
2816     return 0;
2817   *valueP = exp.X_add_number;
2818   return 1;
2819 }
2820
2821 /* Subroutine of sparc_ip to parse an expression.  */
2822
2823 static int
2824 get_expression (str)
2825      char *str;
2826 {
2827   char *save_in;
2828   segT seg;
2829
2830   save_in = input_line_pointer;
2831   input_line_pointer = str;
2832   seg = expression (&the_insn.exp);
2833   if (seg != absolute_section
2834       && seg != text_section
2835       && seg != data_section
2836       && seg != bss_section
2837       && seg != undefined_section)
2838     {
2839       the_insn.error = _("bad segment");
2840       expr_end = input_line_pointer;
2841       input_line_pointer = save_in;
2842       return 1;
2843     }
2844   expr_end = input_line_pointer;
2845   input_line_pointer = save_in;
2846   return 0;
2847 }
2848
2849 /* Subroutine of md_assemble to output one insn.  */
2850
2851 static void
2852 output_insn (insn, the_insn)
2853      const struct sparc_opcode *insn;
2854      struct sparc_it *the_insn;
2855 {
2856   char *toP = frag_more (4);
2857
2858   /* Put out the opcode.  */
2859   if (INSN_BIG_ENDIAN)
2860     number_to_chars_bigendian (toP, (valueT) the_insn->opcode, 4);
2861   else
2862     number_to_chars_littleendian (toP, (valueT) the_insn->opcode, 4);
2863
2864   /* Put out the symbol-dependent stuff.  */
2865   if (the_insn->reloc != BFD_RELOC_NONE)
2866     {
2867       fixS *fixP =  fix_new_exp (frag_now,      /* Which frag.  */
2868                                  (toP - frag_now->fr_literal),  /* Where.  */
2869                                  4,             /* Size.  */
2870                                  &the_insn->exp,
2871                                  the_insn->pcrel,
2872                                  the_insn->reloc);
2873       /* Turn off overflow checking in fixup_segment.  We'll do our
2874          own overflow checking in md_apply_fix3.  This is necessary because
2875          the insn size is 4 and fixup_segment will signal an overflow for
2876          large 8 byte quantities.  */
2877       fixP->fx_no_overflow = 1;
2878       if (the_insn->reloc == BFD_RELOC_SPARC_OLO10)
2879         fixP->tc_fix_data = the_insn->exp2.X_add_number;
2880     }
2881
2882   last_insn = insn;
2883   last_opcode = the_insn->opcode;
2884
2885 #ifdef OBJ_ELF
2886   dwarf2_emit_insn (4);
2887 #endif
2888 }
2889 \f
2890 /* This is identical to the md_atof in m68k.c.  I think this is right,
2891    but I'm not sure.
2892
2893    Turn a string in input_line_pointer into a floating point constant
2894    of type TYPE, and store the appropriate bytes in *LITP.  The number
2895    of LITTLENUMS emitted is stored in *SIZEP.  An error message is
2896    returned, or NULL on OK.  */
2897
2898 /* Equal to MAX_PRECISION in atof-ieee.c.  */
2899 #define MAX_LITTLENUMS 6
2900
2901 char *
2902 md_atof (type, litP, sizeP)
2903      char type;
2904      char *litP;
2905      int *sizeP;
2906 {
2907   int i, prec;
2908   LITTLENUM_TYPE words[MAX_LITTLENUMS];
2909   char *t;
2910
2911   switch (type)
2912     {
2913     case 'f':
2914     case 'F':
2915     case 's':
2916     case 'S':
2917       prec = 2;
2918       break;
2919
2920     case 'd':
2921     case 'D':
2922     case 'r':
2923     case 'R':
2924       prec = 4;
2925       break;
2926
2927     case 'x':
2928     case 'X':
2929       prec = 6;
2930       break;
2931
2932     case 'p':
2933     case 'P':
2934       prec = 6;
2935       break;
2936
2937     default:
2938       *sizeP = 0;
2939       return _("Bad call to MD_ATOF()");
2940     }
2941
2942   t = atof_ieee (input_line_pointer, type, words);
2943   if (t)
2944     input_line_pointer = t;
2945   *sizeP = prec * sizeof (LITTLENUM_TYPE);
2946
2947   if (target_big_endian)
2948     {
2949       for (i = 0; i < prec; i++)
2950         {
2951           md_number_to_chars (litP, (valueT) words[i],
2952                               sizeof (LITTLENUM_TYPE));
2953           litP += sizeof (LITTLENUM_TYPE);
2954         }
2955     }
2956   else
2957     {
2958       for (i = prec - 1; i >= 0; i--)
2959         {
2960           md_number_to_chars (litP, (valueT) words[i],
2961                               sizeof (LITTLENUM_TYPE));
2962           litP += sizeof (LITTLENUM_TYPE);
2963         }
2964     }
2965
2966   return 0;
2967 }
2968
2969 /* Write a value out to the object file, using the appropriate
2970    endianness.  */
2971
2972 void
2973 md_number_to_chars (buf, val, n)
2974      char *buf;
2975      valueT val;
2976      int n;
2977 {
2978   if (target_big_endian)
2979     number_to_chars_bigendian (buf, val, n);
2980   else if (target_little_endian_data
2981            && ((n == 4 || n == 2) && ~now_seg->flags & SEC_ALLOC))
2982     /* Output debug words, which are not in allocated sections, as big
2983        endian.  */
2984     number_to_chars_bigendian (buf, val, n);
2985   else if (target_little_endian_data || ! target_big_endian)
2986     number_to_chars_littleendian (buf, val, n);
2987 }
2988 \f
2989 /* Apply a fixS to the frags, now that we know the value it ought to
2990    hold.  */
2991
2992 void
2993 md_apply_fix3 (fixP, valP, segment)
2994      fixS *fixP;
2995      valueT *valP;
2996      segT segment ATTRIBUTE_UNUSED;
2997 {
2998   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
2999   offsetT val = * (offsetT *) valP;
3000   long insn;
3001
3002   assert (fixP->fx_r_type < BFD_RELOC_UNUSED);
3003
3004   fixP->fx_addnumber = val;     /* Remember value for emit_reloc.  */
3005
3006 #ifdef OBJ_ELF
3007   /* SPARC ELF relocations don't use an addend in the data field.  */
3008   if (fixP->fx_addsy != NULL)
3009     return;
3010 #endif
3011
3012   /* This is a hack.  There should be a better way to
3013      handle this.  Probably in terms of howto fields, once
3014      we can look at these fixups in terms of howtos.  */
3015   if (fixP->fx_r_type == BFD_RELOC_32_PCREL_S2 && fixP->fx_addsy)
3016     val += fixP->fx_where + fixP->fx_frag->fr_address;
3017
3018 #ifdef OBJ_AOUT
3019   /* FIXME: More ridiculous gas reloc hacking.  If we are going to
3020      generate a reloc, then we just want to let the reloc addend set
3021      the value.  We do not want to also stuff the addend into the
3022      object file.  Including the addend in the object file works when
3023      doing a static link, because the linker will ignore the object
3024      file contents.  However, the dynamic linker does not ignore the
3025      object file contents.  */
3026   if (fixP->fx_addsy != NULL
3027       && fixP->fx_r_type != BFD_RELOC_32_PCREL_S2)
3028     val = 0;
3029
3030   /* When generating PIC code, we do not want an addend for a reloc
3031      against a local symbol.  We adjust fx_addnumber to cancel out the
3032      value already included in val, and to also cancel out the
3033      adjustment which bfd_install_relocation will create.  */
3034   if (sparc_pic_code
3035       && fixP->fx_r_type != BFD_RELOC_32_PCREL_S2
3036       && fixP->fx_addsy != NULL
3037       && ! S_IS_COMMON (fixP->fx_addsy)
3038       && symbol_section_p (fixP->fx_addsy))
3039     fixP->fx_addnumber -= 2 * S_GET_VALUE (fixP->fx_addsy);
3040
3041   /* When generating PIC code, we need to fiddle to get
3042      bfd_install_relocation to do the right thing for a PC relative
3043      reloc against a local symbol which we are going to keep.  */
3044   if (sparc_pic_code
3045       && fixP->fx_r_type == BFD_RELOC_32_PCREL_S2
3046       && fixP->fx_addsy != NULL
3047       && (S_IS_EXTERNAL (fixP->fx_addsy)
3048           || S_IS_WEAK (fixP->fx_addsy))
3049       && S_IS_DEFINED (fixP->fx_addsy)
3050       && ! S_IS_COMMON (fixP->fx_addsy))
3051     {
3052       val = 0;
3053       fixP->fx_addnumber -= 2 * S_GET_VALUE (fixP->fx_addsy);
3054     }
3055 #endif
3056
3057   /* If this is a data relocation, just output VAL.  */
3058
3059   if (fixP->fx_r_type == BFD_RELOC_16
3060       || fixP->fx_r_type == BFD_RELOC_SPARC_UA16)
3061     {
3062       md_number_to_chars (buf, val, 2);
3063     }
3064   else if (fixP->fx_r_type == BFD_RELOC_32
3065            || fixP->fx_r_type == BFD_RELOC_SPARC_UA32
3066            || fixP->fx_r_type == BFD_RELOC_SPARC_REV32)
3067     {
3068       md_number_to_chars (buf, val, 4);
3069     }
3070   else if (fixP->fx_r_type == BFD_RELOC_64
3071            || fixP->fx_r_type == BFD_RELOC_SPARC_UA64)
3072     {
3073       md_number_to_chars (buf, val, 8);
3074     }
3075   else if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
3076            || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
3077     {
3078       fixP->fx_done = 0;
3079       return;
3080     }
3081   else
3082     {
3083       /* It's a relocation against an instruction.  */
3084
3085       if (INSN_BIG_ENDIAN)
3086         insn = bfd_getb32 ((unsigned char *) buf);
3087       else
3088         insn = bfd_getl32 ((unsigned char *) buf);
3089
3090       switch (fixP->fx_r_type)
3091         {
3092         case BFD_RELOC_32_PCREL_S2:
3093           val = val >> 2;
3094           /* FIXME: This increment-by-one deserves a comment of why it's
3095              being done!  */
3096           if (! sparc_pic_code
3097               || fixP->fx_addsy == NULL
3098               || symbol_section_p (fixP->fx_addsy))
3099             ++val;
3100
3101           insn |= val & 0x3fffffff;
3102
3103           /* See if we have a delay slot.  */
3104           if (sparc_relax && fixP->fx_where + 8 <= fixP->fx_frag->fr_fix)
3105             {
3106 #define G0              0
3107 #define O7              15
3108 #define XCC             (2 << 20)
3109 #define COND(x)         (((x)&0xf)<<25)
3110 #define CONDA           COND(0x8)
3111 #define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
3112 #define INSN_BA         (F2(0,2) | CONDA)
3113 #define INSN_OR         F3(2, 0x2, 0)
3114 #define INSN_NOP        F2(0,4)
3115
3116               long delay;
3117
3118               /* If the instruction is a call with either:
3119                  restore
3120                  arithmetic instruction with rd == %o7
3121                  where rs1 != %o7 and rs2 if it is register != %o7
3122                  then we can optimize if the call destination is near
3123                  by changing the call into a branch always.  */
3124               if (INSN_BIG_ENDIAN)
3125                 delay = bfd_getb32 ((unsigned char *) buf + 4);
3126               else
3127                 delay = bfd_getl32 ((unsigned char *) buf + 4);
3128               if ((insn & OP (~0)) != OP (1) || (delay & OP (~0)) != OP (2))
3129                 break;
3130               if ((delay & OP3 (~0)) != OP3 (0x3d) /* Restore.  */
3131                   && ((delay & OP3 (0x28)) != 0 /* Arithmetic.  */
3132                       || ((delay & RD (~0)) != RD (O7))))
3133                 break;
3134               if ((delay & RS1 (~0)) == RS1 (O7)
3135                   || ((delay & F3I (~0)) == 0
3136                       && (delay & RS2 (~0)) == RS2 (O7)))
3137                 break;
3138               /* Ensure the branch will fit into simm22.  */
3139               if ((val & 0x3fe00000)
3140                   && (val & 0x3fe00000) != 0x3fe00000)
3141                 break;
3142               /* Check if the arch is v9 and branch will fit
3143                  into simm19.  */
3144               if (((val & 0x3c0000) == 0
3145                    || (val & 0x3c0000) == 0x3c0000)
3146                   && (sparc_arch_size == 64
3147                       || current_architecture >= SPARC_OPCODE_ARCH_V9))
3148                 /* ba,pt %xcc  */
3149                 insn = INSN_BPA | (val & 0x7ffff);
3150               else
3151                 /* ba  */
3152                 insn = INSN_BA | (val & 0x3fffff);
3153               if (fixP->fx_where >= 4
3154                   && ((delay & (0xffffffff ^ RS1 (~0)))
3155                       == (INSN_OR | RD (O7) | RS2 (G0))))
3156                 {
3157                   long setter;
3158                   int reg;
3159
3160                   if (INSN_BIG_ENDIAN)
3161                     setter = bfd_getb32 ((unsigned char *) buf - 4);
3162                   else
3163                     setter = bfd_getl32 ((unsigned char *) buf - 4);
3164                   if ((setter & (0xffffffff ^ RD (~0)))
3165                       != (INSN_OR | RS1 (O7) | RS2 (G0)))
3166                     break;
3167                   /* The sequence was
3168                      or %o7, %g0, %rN
3169                      call foo
3170                      or %rN, %g0, %o7
3171
3172                      If call foo was replaced with ba, replace
3173                      or %rN, %g0, %o7 with nop.  */
3174                   reg = (delay & RS1 (~0)) >> 14;
3175                   if (reg != ((setter & RD (~0)) >> 25)
3176                       || reg == G0 || reg == O7)
3177                     break;
3178
3179                   if (INSN_BIG_ENDIAN)
3180                     bfd_putb32 (INSN_NOP, (unsigned char *) buf + 4);
3181                   else
3182                     bfd_putl32 (INSN_NOP, (unsigned char *) buf + 4);
3183                 }
3184             }
3185           break;
3186
3187         case BFD_RELOC_SPARC_11:
3188           if (! in_signed_range (val, 0x7ff))
3189             as_bad_where (fixP->fx_file, fixP->fx_line,
3190                           _("relocation overflow"));
3191           insn |= val & 0x7ff;
3192           break;
3193
3194         case BFD_RELOC_SPARC_10:
3195           if (! in_signed_range (val, 0x3ff))
3196             as_bad_where (fixP->fx_file, fixP->fx_line,
3197                           _("relocation overflow"));
3198           insn |= val & 0x3ff;
3199           break;
3200
3201         case BFD_RELOC_SPARC_7:
3202           if (! in_bitfield_range (val, 0x7f))
3203             as_bad_where (fixP->fx_file, fixP->fx_line,
3204                           _("relocation overflow"));
3205           insn |= val & 0x7f;
3206           break;
3207
3208         case BFD_RELOC_SPARC_6:
3209           if (! in_bitfield_range (val, 0x3f))
3210             as_bad_where (fixP->fx_file, fixP->fx_line,
3211                           _("relocation overflow"));
3212           insn |= val & 0x3f;
3213           break;
3214
3215         case BFD_RELOC_SPARC_5:
3216           if (! in_bitfield_range (val, 0x1f))
3217             as_bad_where (fixP->fx_file, fixP->fx_line,
3218                           _("relocation overflow"));
3219           insn |= val & 0x1f;
3220           break;
3221
3222         case BFD_RELOC_SPARC_WDISP16:
3223           /* FIXME: simplify.  */
3224           if (((val > 0) && (val & ~0x3fffc))
3225               || ((val < 0) && (~(val - 1) & ~0x3fffc)))
3226             as_bad_where (fixP->fx_file, fixP->fx_line,
3227                           _("relocation overflow"));
3228           /* FIXME: The +1 deserves a comment.  */
3229           val = (val >> 2) + 1;
3230           insn |= ((val & 0xc000) << 6) | (val & 0x3fff);
3231           break;
3232
3233         case BFD_RELOC_SPARC_WDISP19:
3234           /* FIXME: simplify.  */
3235           if (((val > 0) && (val & ~0x1ffffc))
3236               || ((val < 0) && (~(val - 1) & ~0x1ffffc)))
3237             as_bad_where (fixP->fx_file, fixP->fx_line,
3238                           _("relocation overflow"));
3239           /* FIXME: The +1 deserves a comment.  */
3240           val = (val >> 2) + 1;
3241           insn |= val & 0x7ffff;
3242           break;
3243
3244         case BFD_RELOC_SPARC_HH22:
3245           val = BSR (val, 32);
3246           /* Fall through.  */
3247
3248         case BFD_RELOC_SPARC_LM22:
3249         case BFD_RELOC_HI22:
3250           if (!fixP->fx_addsy)
3251             insn |= (val >> 10) & 0x3fffff;
3252           else
3253             /* FIXME: Need comment explaining why we do this.  */
3254             insn &= ~0xffff;
3255           break;
3256
3257         case BFD_RELOC_SPARC22:
3258           if (val & ~0x003fffff)
3259             as_bad_where (fixP->fx_file, fixP->fx_line,
3260                           _("relocation overflow"));
3261           insn |= (val & 0x3fffff);
3262           break;
3263
3264         case BFD_RELOC_SPARC_HM10:
3265           val = BSR (val, 32);
3266           /* Fall through.  */
3267
3268         case BFD_RELOC_LO10:
3269           if (!fixP->fx_addsy)
3270             insn |= val & 0x3ff;
3271           else
3272             /* FIXME: Need comment explaining why we do this.  */
3273             insn &= ~0xff;
3274           break;
3275
3276         case BFD_RELOC_SPARC_OLO10:
3277           val &= 0x3ff;
3278           val += fixP->tc_fix_data;
3279           /* Fall through.  */
3280
3281         case BFD_RELOC_SPARC13:
3282           if (! in_signed_range (val, 0x1fff))
3283             as_bad_where (fixP->fx_file, fixP->fx_line,
3284                           _("relocation overflow"));
3285           insn |= val & 0x1fff;
3286           break;
3287
3288         case BFD_RELOC_SPARC_WDISP22:
3289           val = (val >> 2) + 1;
3290           /* Fall through.  */
3291         case BFD_RELOC_SPARC_BASE22:
3292           insn |= val & 0x3fffff;
3293           break;
3294
3295         case BFD_RELOC_SPARC_H44:
3296           if (!fixP->fx_addsy)
3297             {
3298               bfd_vma tval = val;
3299               tval >>= 22;
3300               insn |= tval & 0x3fffff;
3301             }
3302           break;
3303
3304         case BFD_RELOC_SPARC_M44:
3305           if (!fixP->fx_addsy)
3306             insn |= (val >> 12) & 0x3ff;
3307           break;
3308
3309         case BFD_RELOC_SPARC_L44:
3310           if (!fixP->fx_addsy)
3311             insn |= val & 0xfff;
3312           break;
3313
3314         case BFD_RELOC_SPARC_HIX22:
3315           if (!fixP->fx_addsy)
3316             {
3317               val ^= ~(offsetT) 0;
3318               insn |= (val >> 10) & 0x3fffff;
3319             }
3320           break;
3321
3322         case BFD_RELOC_SPARC_LOX10:
3323           if (!fixP->fx_addsy)
3324             insn |= 0x1c00 | (val & 0x3ff);
3325           break;
3326
3327         case BFD_RELOC_NONE:
3328         default:
3329           as_bad_where (fixP->fx_file, fixP->fx_line,
3330                         _("bad or unhandled relocation type: 0x%02x"),
3331                         fixP->fx_r_type);
3332           break;
3333         }
3334
3335       if (INSN_BIG_ENDIAN)
3336         bfd_putb32 (insn, (unsigned char *) buf);
3337       else
3338         bfd_putl32 (insn, (unsigned char *) buf);
3339     }
3340
3341   /* Are we finished with this relocation now?  */
3342   if (fixP->fx_addsy == 0 && !fixP->fx_pcrel)
3343     fixP->fx_done = 1;
3344 }
3345
3346 /* Translate internal representation of relocation info to BFD target
3347    format.  */
3348
3349 arelent **
3350 tc_gen_reloc (section, fixp)
3351      asection *section ATTRIBUTE_UNUSED;
3352      fixS *fixp;
3353 {
3354   static arelent *relocs[3];
3355   arelent *reloc;
3356   bfd_reloc_code_real_type code;
3357
3358   relocs[0] = reloc = (arelent *) xmalloc (sizeof (arelent));
3359   relocs[1] = NULL;
3360
3361   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
3362   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
3363   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
3364
3365   switch (fixp->fx_r_type)
3366     {
3367     case BFD_RELOC_16:
3368     case BFD_RELOC_32:
3369     case BFD_RELOC_HI22:
3370     case BFD_RELOC_LO10:
3371     case BFD_RELOC_32_PCREL_S2:
3372     case BFD_RELOC_SPARC13:
3373     case BFD_RELOC_SPARC22:
3374     case BFD_RELOC_SPARC_BASE13:
3375     case BFD_RELOC_SPARC_WDISP16:
3376     case BFD_RELOC_SPARC_WDISP19:
3377     case BFD_RELOC_SPARC_WDISP22:
3378     case BFD_RELOC_64:
3379     case BFD_RELOC_SPARC_5:
3380     case BFD_RELOC_SPARC_6:
3381     case BFD_RELOC_SPARC_7:
3382     case BFD_RELOC_SPARC_10:
3383     case BFD_RELOC_SPARC_11:
3384     case BFD_RELOC_SPARC_HH22:
3385     case BFD_RELOC_SPARC_HM10:
3386     case BFD_RELOC_SPARC_LM22:
3387     case BFD_RELOC_SPARC_PC_HH22:
3388     case BFD_RELOC_SPARC_PC_HM10:
3389     case BFD_RELOC_SPARC_PC_LM22:
3390     case BFD_RELOC_SPARC_H44:
3391     case BFD_RELOC_SPARC_M44:
3392     case BFD_RELOC_SPARC_L44:
3393     case BFD_RELOC_SPARC_HIX22:
3394     case BFD_RELOC_SPARC_LOX10:
3395     case BFD_RELOC_SPARC_REV32:
3396     case BFD_RELOC_SPARC_OLO10:
3397     case BFD_RELOC_SPARC_UA16:
3398     case BFD_RELOC_SPARC_UA32:
3399     case BFD_RELOC_SPARC_UA64:
3400     case BFD_RELOC_8_PCREL:
3401     case BFD_RELOC_16_PCREL:
3402     case BFD_RELOC_32_PCREL:
3403     case BFD_RELOC_64_PCREL:
3404     case BFD_RELOC_SPARC_PLT32:
3405     case BFD_RELOC_SPARC_PLT64:
3406     case BFD_RELOC_VTABLE_ENTRY:
3407     case BFD_RELOC_VTABLE_INHERIT:
3408     case BFD_RELOC_SPARC_TLS_GD_HI22:
3409     case BFD_RELOC_SPARC_TLS_GD_LO10:
3410     case BFD_RELOC_SPARC_TLS_GD_ADD:
3411     case BFD_RELOC_SPARC_TLS_GD_CALL:
3412     case BFD_RELOC_SPARC_TLS_LDM_HI22:
3413     case BFD_RELOC_SPARC_TLS_LDM_LO10:
3414     case BFD_RELOC_SPARC_TLS_LDM_ADD:
3415     case BFD_RELOC_SPARC_TLS_LDM_CALL:
3416     case BFD_RELOC_SPARC_TLS_LDO_HIX22:
3417     case BFD_RELOC_SPARC_TLS_LDO_LOX10:
3418     case BFD_RELOC_SPARC_TLS_LDO_ADD:
3419     case BFD_RELOC_SPARC_TLS_IE_HI22:
3420     case BFD_RELOC_SPARC_TLS_IE_LO10:
3421     case BFD_RELOC_SPARC_TLS_IE_LD:
3422     case BFD_RELOC_SPARC_TLS_IE_LDX:
3423     case BFD_RELOC_SPARC_TLS_IE_ADD:
3424     case BFD_RELOC_SPARC_TLS_LE_HIX22:
3425     case BFD_RELOC_SPARC_TLS_LE_LOX10:
3426     case BFD_RELOC_SPARC_TLS_DTPOFF32:
3427     case BFD_RELOC_SPARC_TLS_DTPOFF64:
3428       code = fixp->fx_r_type;
3429       break;
3430     default:
3431       abort ();
3432       return NULL;
3433     }
3434
3435 #if defined (OBJ_ELF) || defined (OBJ_AOUT)
3436   /* If we are generating PIC code, we need to generate a different
3437      set of relocs.  */
3438
3439 #ifdef OBJ_ELF
3440 #define GOT_NAME "_GLOBAL_OFFSET_TABLE_"
3441 #else
3442 #define GOT_NAME "__GLOBAL_OFFSET_TABLE_"
3443 #endif
3444
3445   /* This code must be parallel to the OBJ_ELF tc_fix_adjustable.  */
3446
3447   if (sparc_pic_code)
3448     {
3449       switch (code)
3450         {
3451         case BFD_RELOC_32_PCREL_S2:
3452           if (generic_force_reloc (fixp))
3453             code = BFD_RELOC_SPARC_WPLT30;
3454           break;
3455         case BFD_RELOC_HI22:
3456           if (fixp->fx_addsy != NULL
3457               && strcmp (S_GET_NAME (fixp->fx_addsy), GOT_NAME) == 0)
3458             code = BFD_RELOC_SPARC_PC22;
3459           else
3460             code = BFD_RELOC_SPARC_GOT22;
3461           break;
3462         case BFD_RELOC_LO10:
3463           if (fixp->fx_addsy != NULL
3464               && strcmp (S_GET_NAME (fixp->fx_addsy), GOT_NAME) == 0)
3465             code = BFD_RELOC_SPARC_PC10;
3466           else
3467             code = BFD_RELOC_SPARC_GOT10;
3468           break;
3469         case BFD_RELOC_SPARC13:
3470           code = BFD_RELOC_SPARC_GOT13;
3471           break;
3472         default:
3473           break;
3474         }
3475     }
3476 #endif /* defined (OBJ_ELF) || defined (OBJ_AOUT)  */
3477
3478   if (code == BFD_RELOC_SPARC_OLO10)
3479     reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_LO10);
3480   else
3481     reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
3482   if (reloc->howto == 0)
3483     {
3484       as_bad_where (fixp->fx_file, fixp->fx_line,
3485                     _("internal error: can't export reloc type %d (`%s')"),
3486                     fixp->fx_r_type, bfd_get_reloc_code_name (code));
3487       xfree (reloc);
3488       relocs[0] = NULL;
3489       return relocs;
3490     }
3491
3492   /* @@ Why fx_addnumber sometimes and fx_offset other times?  */
3493 #ifdef OBJ_AOUT
3494
3495   if (reloc->howto->pc_relative == 0
3496       || code == BFD_RELOC_SPARC_PC10
3497       || code == BFD_RELOC_SPARC_PC22)
3498     reloc->addend = fixp->fx_addnumber;
3499   else if (sparc_pic_code
3500            && fixp->fx_r_type == BFD_RELOC_32_PCREL_S2
3501            && fixp->fx_addsy != NULL
3502            && (S_IS_EXTERNAL (fixp->fx_addsy)
3503                || S_IS_WEAK (fixp->fx_addsy))
3504            && S_IS_DEFINED (fixp->fx_addsy)
3505            && ! S_IS_COMMON (fixp->fx_addsy))
3506     reloc->addend = fixp->fx_addnumber;
3507   else
3508     reloc->addend = fixp->fx_offset - reloc->address;
3509
3510 #else /* elf or coff  */
3511
3512   if (code != BFD_RELOC_32_PCREL_S2
3513       && code != BFD_RELOC_SPARC_WDISP22
3514       && code != BFD_RELOC_SPARC_WDISP16
3515       && code != BFD_RELOC_SPARC_WDISP19
3516       && code != BFD_RELOC_SPARC_WPLT30
3517       && code != BFD_RELOC_SPARC_TLS_GD_CALL
3518       && code != BFD_RELOC_SPARC_TLS_LDM_CALL)
3519     reloc->addend = fixp->fx_addnumber;
3520   else if (symbol_section_p (fixp->fx_addsy))
3521     reloc->addend = (section->vma
3522                      + fixp->fx_addnumber
3523                      + md_pcrel_from (fixp));
3524   else
3525     reloc->addend = fixp->fx_offset;
3526 #endif
3527
3528   /* We expand R_SPARC_OLO10 to R_SPARC_LO10 and R_SPARC_13
3529      on the same location.  */
3530   if (code == BFD_RELOC_SPARC_OLO10)
3531     {
3532       relocs[1] = reloc = (arelent *) xmalloc (sizeof (arelent));
3533       relocs[2] = NULL;
3534
3535       reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
3536       *reloc->sym_ptr_ptr
3537         = symbol_get_bfdsym (section_symbol (absolute_section));
3538       reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
3539       reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_SPARC13);
3540       reloc->addend = fixp->tc_fix_data;
3541     }
3542
3543   return relocs;
3544 }
3545 \f
3546 /* We have no need to default values of symbols.  */
3547
3548 symbolS *
3549 md_undefined_symbol (name)
3550      char *name ATTRIBUTE_UNUSED;
3551 {
3552   return 0;
3553 }
3554
3555 /* Round up a section size to the appropriate boundary.  */
3556
3557 valueT
3558 md_section_align (segment, size)
3559      segT segment ATTRIBUTE_UNUSED;
3560      valueT size;
3561 {
3562 #ifndef OBJ_ELF
3563   /* This is not right for ELF; a.out wants it, and COFF will force
3564      the alignment anyways.  */
3565   valueT align = ((valueT) 1
3566                   << (valueT) bfd_get_section_alignment (stdoutput, segment));
3567   valueT newsize;
3568
3569   /* Turn alignment value into a mask.  */
3570   align--;
3571   newsize = (size + align) & ~align;
3572   return newsize;
3573 #else
3574   return size;
3575 #endif
3576 }
3577
3578 /* Exactly what point is a PC-relative offset relative TO?
3579    On the sparc, they're relative to the address of the offset, plus
3580    its size.  This gets us to the following instruction.
3581    (??? Is this right?  FIXME-SOON)  */
3582 long
3583 md_pcrel_from (fixP)
3584      fixS *fixP;
3585 {
3586   long ret;
3587
3588   ret = fixP->fx_where + fixP->fx_frag->fr_address;
3589   if (! sparc_pic_code
3590       || fixP->fx_addsy == NULL
3591       || symbol_section_p (fixP->fx_addsy))
3592     ret += fixP->fx_size;
3593   return ret;
3594 }
3595 \f
3596 /* Return log2 (VALUE), or -1 if VALUE is not an exact positive power
3597    of two.  */
3598
3599 static int
3600 log2 (value)
3601      int value;
3602 {
3603   int shift;
3604
3605   if (value <= 0)
3606     return -1;
3607
3608   for (shift = 0; (value & 1) == 0; value >>= 1)
3609     ++shift;
3610
3611   return (value == 1) ? shift : -1;
3612 }
3613
3614 /* Sort of like s_lcomm.  */
3615
3616 #ifndef OBJ_ELF
3617 static int max_alignment = 15;
3618 #endif
3619
3620 static void
3621 s_reserve (ignore)
3622      int ignore ATTRIBUTE_UNUSED;
3623 {
3624   char *name;
3625   char *p;
3626   char c;
3627   int align;
3628   int size;
3629   int temp;
3630   symbolS *symbolP;
3631
3632   name = input_line_pointer;
3633   c = get_symbol_end ();
3634   p = input_line_pointer;
3635   *p = c;
3636   SKIP_WHITESPACE ();
3637
3638   if (*input_line_pointer != ',')
3639     {
3640       as_bad (_("Expected comma after name"));
3641       ignore_rest_of_line ();
3642       return;
3643     }
3644
3645   ++input_line_pointer;
3646
3647   if ((size = get_absolute_expression ()) < 0)
3648     {
3649       as_bad (_("BSS length (%d.) <0! Ignored."), size);
3650       ignore_rest_of_line ();
3651       return;
3652     }                           /* Bad length.  */
3653
3654   *p = 0;
3655   symbolP = symbol_find_or_make (name);
3656   *p = c;
3657
3658   if (strncmp (input_line_pointer, ",\"bss\"", 6) != 0
3659       && strncmp (input_line_pointer, ",\".bss\"", 7) != 0)
3660     {
3661       as_bad (_("bad .reserve segment -- expected BSS segment"));
3662       return;
3663     }
3664
3665   if (input_line_pointer[2] == '.')
3666     input_line_pointer += 7;
3667   else
3668     input_line_pointer += 6;
3669   SKIP_WHITESPACE ();
3670
3671   if (*input_line_pointer == ',')
3672     {
3673       ++input_line_pointer;
3674
3675       SKIP_WHITESPACE ();
3676       if (*input_line_pointer == '\n')
3677         {
3678           as_bad (_("missing alignment"));
3679           ignore_rest_of_line ();
3680           return;
3681         }
3682
3683       align = (int) get_absolute_expression ();
3684
3685 #ifndef OBJ_ELF
3686       if (align > max_alignment)
3687         {
3688           align = max_alignment;
3689           as_warn (_("alignment too large; assuming %d"), align);
3690         }
3691 #endif
3692
3693       if (align < 0)
3694         {
3695           as_bad (_("negative alignment"));
3696           ignore_rest_of_line ();
3697           return;
3698         }
3699
3700       if (align != 0)
3701         {
3702           temp = log2 (align);
3703           if (temp < 0)
3704             {
3705               as_bad (_("alignment not a power of 2"));
3706               ignore_rest_of_line ();
3707               return;
3708             }
3709
3710           align = temp;
3711         }
3712
3713       record_alignment (bss_section, align);
3714     }
3715   else
3716     align = 0;
3717
3718   if (!S_IS_DEFINED (symbolP)
3719 #ifdef OBJ_AOUT
3720       && S_GET_OTHER (symbolP) == 0
3721       && S_GET_DESC (symbolP) == 0
3722 #endif
3723       )
3724     {
3725       if (! need_pass_2)
3726         {
3727           char *pfrag;
3728           segT current_seg = now_seg;
3729           subsegT current_subseg = now_subseg;
3730
3731           /* Switch to bss.  */
3732           subseg_set (bss_section, 1);
3733
3734           if (align)
3735             /* Do alignment.  */
3736             frag_align (align, 0, 0);
3737
3738           /* Detach from old frag.  */
3739           if (S_GET_SEGMENT (symbolP) == bss_section)
3740             symbol_get_frag (symbolP)->fr_symbol = NULL;
3741
3742           symbol_set_frag (symbolP, frag_now);
3743           pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
3744                             (offsetT) size, (char *) 0);
3745           *pfrag = 0;
3746
3747           S_SET_SEGMENT (symbolP, bss_section);
3748
3749           subseg_set (current_seg, current_subseg);
3750
3751 #ifdef OBJ_ELF
3752           S_SET_SIZE (symbolP, size);
3753 #endif
3754         }
3755     }
3756   else
3757     {
3758       as_warn ("Ignoring attempt to re-define symbol %s",
3759                S_GET_NAME (symbolP));
3760     }                           /* if not redefining.  */
3761
3762   demand_empty_rest_of_line ();
3763 }
3764
3765 static void
3766 s_common (ignore)
3767      int ignore ATTRIBUTE_UNUSED;
3768 {
3769   char *name;
3770   char c;
3771   char *p;
3772   offsetT temp, size;
3773   symbolS *symbolP;
3774
3775   name = input_line_pointer;
3776   c = get_symbol_end ();
3777   /* Just after name is now '\0'.  */
3778   p = input_line_pointer;
3779   *p = c;
3780   SKIP_WHITESPACE ();
3781   if (*input_line_pointer != ',')
3782     {
3783       as_bad (_("Expected comma after symbol-name"));
3784       ignore_rest_of_line ();
3785       return;
3786     }
3787
3788   /* Skip ','.  */
3789   input_line_pointer++;
3790
3791   if ((temp = get_absolute_expression ()) < 0)
3792     {
3793       as_bad (_(".COMMon length (%lu) out of range ignored"),
3794               (unsigned long) temp);
3795       ignore_rest_of_line ();
3796       return;
3797     }
3798   size = temp;
3799   *p = 0;
3800   symbolP = symbol_find_or_make (name);
3801   *p = c;
3802   if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
3803     {
3804       as_bad (_("Ignoring attempt to re-define symbol"));
3805       ignore_rest_of_line ();
3806       return;
3807     }
3808   if (S_GET_VALUE (symbolP) != 0)
3809     {
3810       if (S_GET_VALUE (symbolP) != (valueT) size)
3811         {
3812           as_warn (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
3813                    S_GET_NAME (symbolP), (long) S_GET_VALUE (symbolP), (long) size);
3814         }
3815     }
3816   else
3817     {
3818 #ifndef OBJ_ELF
3819       S_SET_VALUE (symbolP, (valueT) size);
3820       S_SET_EXTERNAL (symbolP);
3821 #endif
3822     }
3823   know (symbol_get_frag (symbolP) == &zero_address_frag);
3824   if (*input_line_pointer != ',')
3825     {
3826       as_bad (_("Expected comma after common length"));
3827       ignore_rest_of_line ();
3828       return;
3829     }
3830   input_line_pointer++;
3831   SKIP_WHITESPACE ();
3832   if (*input_line_pointer != '"')
3833     {
3834       temp = get_absolute_expression ();
3835
3836 #ifndef OBJ_ELF
3837       if (temp > max_alignment)
3838         {
3839           temp = max_alignment;
3840           as_warn (_("alignment too large; assuming %d"), temp);
3841         }
3842 #endif
3843
3844       if (temp < 0)
3845         {
3846           as_bad (_("negative alignment"));
3847           ignore_rest_of_line ();
3848           return;
3849         }
3850
3851 #ifdef OBJ_ELF
3852       if (symbol_get_obj (symbolP)->local)
3853         {
3854           segT old_sec;
3855           int old_subsec;
3856           char *p;
3857           int align;
3858
3859           old_sec = now_seg;
3860           old_subsec = now_subseg;
3861
3862           if (temp == 0)
3863             align = 0;
3864           else
3865             align = log2 (temp);
3866
3867           if (align < 0)
3868             {
3869               as_bad (_("alignment not a power of 2"));
3870               ignore_rest_of_line ();
3871               return;
3872             }
3873
3874           record_alignment (bss_section, align);
3875           subseg_set (bss_section, 0);
3876           if (align)
3877             frag_align (align, 0, 0);
3878           if (S_GET_SEGMENT (symbolP) == bss_section)
3879             symbol_get_frag (symbolP)->fr_symbol = 0;
3880           symbol_set_frag (symbolP, frag_now);
3881           p = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
3882                         (offsetT) size, (char *) 0);
3883           *p = 0;
3884           S_SET_SEGMENT (symbolP, bss_section);
3885           S_CLEAR_EXTERNAL (symbolP);
3886           S_SET_SIZE (symbolP, size);
3887           subseg_set (old_sec, old_subsec);
3888         }
3889       else
3890 #endif /* OBJ_ELF  */
3891         {
3892         allocate_common:
3893           S_SET_VALUE (symbolP, (valueT) size);
3894 #ifdef OBJ_ELF
3895           S_SET_ALIGN (symbolP, temp);
3896           S_SET_SIZE (symbolP, size);
3897 #endif
3898           S_SET_EXTERNAL (symbolP);
3899           S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
3900         }
3901     }
3902   else
3903     {
3904       input_line_pointer++;
3905       /* @@ Some use the dot, some don't.  Can we get some consistency??  */
3906       if (*input_line_pointer == '.')
3907         input_line_pointer++;
3908       /* @@ Some say data, some say bss.  */
3909       if (strncmp (input_line_pointer, "bss\"", 4)
3910           && strncmp (input_line_pointer, "data\"", 5))
3911         {
3912           while (*--input_line_pointer != '"')
3913             ;
3914           input_line_pointer--;
3915           goto bad_common_segment;
3916         }
3917       while (*input_line_pointer++ != '"')
3918         ;
3919       goto allocate_common;
3920     }
3921
3922 #ifdef BFD_ASSEMBLER
3923   symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
3924 #endif
3925
3926   demand_empty_rest_of_line ();
3927   return;
3928
3929   {
3930   bad_common_segment:
3931     p = input_line_pointer;
3932     while (*p && *p != '\n')
3933       p++;
3934     c = *p;
3935     *p = '\0';
3936     as_bad (_("bad .common segment %s"), input_line_pointer + 1);
3937     *p = c;
3938     input_line_pointer = p;
3939     ignore_rest_of_line ();
3940     return;
3941   }
3942 }
3943
3944 /* Handle the .empty pseudo-op.  This suppresses the warnings about
3945    invalid delay slot usage.  */
3946
3947 static void
3948 s_empty (ignore)
3949      int ignore ATTRIBUTE_UNUSED;
3950 {
3951   /* The easy way to implement is to just forget about the last
3952      instruction.  */
3953   last_insn = NULL;
3954 }
3955
3956 static void
3957 s_seg (ignore)
3958      int ignore ATTRIBUTE_UNUSED;
3959 {
3960
3961   if (strncmp (input_line_pointer, "\"text\"", 6) == 0)
3962     {
3963       input_line_pointer += 6;
3964       s_text (0);
3965       return;
3966     }
3967   if (strncmp (input_line_pointer, "\"data\"", 6) == 0)
3968     {
3969       input_line_pointer += 6;
3970       s_data (0);
3971       return;
3972     }
3973   if (strncmp (input_line_pointer, "\"data1\"", 7) == 0)
3974     {
3975       input_line_pointer += 7;
3976       s_data1 ();
3977       return;
3978     }
3979   if (strncmp (input_line_pointer, "\"bss\"", 5) == 0)
3980     {
3981       input_line_pointer += 5;
3982       /* We only support 2 segments -- text and data -- for now, so
3983          things in the "bss segment" will have to go into data for now.
3984          You can still allocate SEG_BSS stuff with .lcomm or .reserve.  */
3985       subseg_set (data_section, 255);   /* FIXME-SOMEDAY.  */
3986       return;
3987     }
3988   as_bad (_("Unknown segment type"));
3989   demand_empty_rest_of_line ();
3990 }
3991
3992 static void
3993 s_data1 ()
3994 {
3995   subseg_set (data_section, 1);
3996   demand_empty_rest_of_line ();
3997 }
3998
3999 static void
4000 s_proc (ignore)
4001      int ignore ATTRIBUTE_UNUSED;
4002 {
4003   while (!is_end_of_line[(unsigned char) *input_line_pointer])
4004     {
4005       ++input_line_pointer;
4006     }
4007   ++input_line_pointer;
4008 }
4009
4010 /* This static variable is set by s_uacons to tell sparc_cons_align
4011    that the expression does not need to be aligned.  */
4012
4013 static int sparc_no_align_cons = 0;
4014
4015 /* This static variable is set by sparc_cons to emit requested types
4016    of relocations in cons_fix_new_sparc.  */
4017
4018 static const char *sparc_cons_special_reloc;
4019
4020 /* This handles the unaligned space allocation pseudo-ops, such as
4021    .uaword.  .uaword is just like .word, but the value does not need
4022    to be aligned.  */
4023
4024 static void
4025 s_uacons (bytes)
4026      int bytes;
4027 {
4028   /* Tell sparc_cons_align not to align this value.  */
4029   sparc_no_align_cons = 1;
4030   cons (bytes);
4031   sparc_no_align_cons = 0;
4032 }
4033
4034 /* This handles the native word allocation pseudo-op .nword.
4035    For sparc_arch_size 32 it is equivalent to .word,  for
4036    sparc_arch_size 64 it is equivalent to .xword.  */
4037
4038 static void
4039 s_ncons (bytes)
4040      int bytes ATTRIBUTE_UNUSED;
4041 {
4042   cons (sparc_arch_size == 32 ? 4 : 8);
4043 }
4044
4045 #ifdef OBJ_ELF
4046 /* Handle the SPARC ELF .register pseudo-op.  This sets the binding of a
4047    global register.
4048    The syntax is:
4049
4050    .register %g[2367],{#scratch|symbolname|#ignore}
4051 */
4052
4053 static void
4054 s_register (ignore)
4055      int ignore ATTRIBUTE_UNUSED;
4056 {
4057   char c;
4058   int reg;
4059   int flags;
4060   const char *regname;
4061
4062   if (input_line_pointer[0] != '%'
4063       || input_line_pointer[1] != 'g'
4064       || ((input_line_pointer[2] & ~1) != '2'
4065           && (input_line_pointer[2] & ~1) != '6')
4066       || input_line_pointer[3] != ',')
4067     as_bad (_("register syntax is .register %%g[2367],{#scratch|symbolname|#ignore}"));
4068   reg = input_line_pointer[2] - '0';
4069   input_line_pointer += 4;
4070
4071   if (*input_line_pointer == '#')
4072     {
4073       ++input_line_pointer;
4074       regname = input_line_pointer;
4075       c = get_symbol_end ();
4076       if (strcmp (regname, "scratch") && strcmp (regname, "ignore"))
4077         as_bad (_("register syntax is .register %%g[2367],{#scratch|symbolname|#ignore}"));
4078       if (regname[0] == 'i')
4079         regname = NULL;
4080       else
4081         regname = "";
4082     }
4083   else
4084     {
4085       regname = input_line_pointer;
4086       c = get_symbol_end ();
4087     }
4088   if (sparc_arch_size == 64)
4089     {
4090       if (globals[reg])
4091         {
4092           if ((regname && globals[reg] != (symbolS *) 1
4093                && strcmp (S_GET_NAME (globals[reg]), regname))
4094               || ((regname != NULL) ^ (globals[reg] != (symbolS *) 1)))
4095             as_bad (_("redefinition of global register"));
4096         }
4097       else
4098         {
4099           if (regname == NULL)
4100             globals[reg] = (symbolS *) 1;
4101           else
4102             {
4103               if (*regname)
4104                 {
4105                   if (symbol_find (regname))
4106                     as_bad (_("Register symbol %s already defined."),
4107                             regname);
4108                 }
4109               globals[reg] = symbol_make (regname);
4110               flags = symbol_get_bfdsym (globals[reg])->flags;
4111               if (! *regname)
4112                 flags = flags & ~(BSF_GLOBAL|BSF_LOCAL|BSF_WEAK);
4113               if (! (flags & (BSF_GLOBAL|BSF_LOCAL|BSF_WEAK)))
4114                 flags |= BSF_GLOBAL;
4115               symbol_get_bfdsym (globals[reg])->flags = flags;
4116               S_SET_VALUE (globals[reg], (valueT) reg);
4117               S_SET_ALIGN (globals[reg], reg);
4118               S_SET_SIZE (globals[reg], 0);
4119               /* Although we actually want undefined_section here,
4120                  we have to use absolute_section, because otherwise
4121                  generic as code will make it a COM section.
4122                  We fix this up in sparc_adjust_symtab.  */
4123               S_SET_SEGMENT (globals[reg], absolute_section);
4124               S_SET_OTHER (globals[reg], 0);
4125               elf_symbol (symbol_get_bfdsym (globals[reg]))
4126                 ->internal_elf_sym.st_info =
4127                   ELF_ST_INFO(STB_GLOBAL, STT_REGISTER);
4128               elf_symbol (symbol_get_bfdsym (globals[reg]))
4129                 ->internal_elf_sym.st_shndx = SHN_UNDEF;
4130             }
4131         }
4132     }
4133
4134   *input_line_pointer = c;
4135
4136   demand_empty_rest_of_line ();
4137 }
4138
4139 /* Adjust the symbol table.  We set undefined sections for STT_REGISTER
4140    symbols which need it.  */
4141
4142 void
4143 sparc_adjust_symtab ()
4144 {
4145   symbolS *sym;
4146
4147   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
4148     {
4149       if (ELF_ST_TYPE (elf_symbol (symbol_get_bfdsym (sym))
4150                        ->internal_elf_sym.st_info) != STT_REGISTER)
4151         continue;
4152
4153       if (ELF_ST_TYPE (elf_symbol (symbol_get_bfdsym (sym))
4154                        ->internal_elf_sym.st_shndx != SHN_UNDEF))
4155         continue;
4156
4157       S_SET_SEGMENT (sym, undefined_section);
4158     }
4159 }
4160 #endif
4161
4162 /* If the --enforce-aligned-data option is used, we require .word,
4163    et. al., to be aligned correctly.  We do it by setting up an
4164    rs_align_code frag, and checking in HANDLE_ALIGN to make sure that
4165    no unexpected alignment was introduced.
4166
4167    The SunOS and Solaris native assemblers enforce aligned data by
4168    default.  We don't want to do that, because gcc can deliberately
4169    generate misaligned data if the packed attribute is used.  Instead,
4170    we permit misaligned data by default, and permit the user to set an
4171    option to check for it.  */
4172
4173 void
4174 sparc_cons_align (nbytes)
4175      int nbytes;
4176 {
4177   int nalign;
4178   char *p;
4179
4180   /* Only do this if we are enforcing aligned data.  */
4181   if (! enforce_aligned_data)
4182     return;
4183
4184   /* Don't align if this is an unaligned pseudo-op.  */
4185   if (sparc_no_align_cons)
4186     return;
4187
4188   nalign = log2 (nbytes);
4189   if (nalign == 0)
4190     return;
4191
4192   assert (nalign > 0);
4193
4194   if (now_seg == absolute_section)
4195     {
4196       if ((abs_section_offset & ((1 << nalign) - 1)) != 0)
4197         as_bad (_("misaligned data"));
4198       return;
4199     }
4200
4201   p = frag_var (rs_align_test, 1, 1, (relax_substateT) 0,
4202                 (symbolS *) NULL, (offsetT) nalign, (char *) NULL);
4203
4204   record_alignment (now_seg, nalign);
4205 }
4206
4207 /* This is called from HANDLE_ALIGN in tc-sparc.h.  */
4208
4209 void
4210 sparc_handle_align (fragp)
4211      fragS *fragp;
4212 {
4213   int count, fix;
4214   char *p;
4215
4216   count = fragp->fr_next->fr_address - fragp->fr_address - fragp->fr_fix;
4217
4218   switch (fragp->fr_type)
4219     {
4220     case rs_align_test:
4221       if (count != 0)
4222         as_bad_where (fragp->fr_file, fragp->fr_line, _("misaligned data"));
4223       break;
4224
4225     case rs_align_code:
4226       p = fragp->fr_literal + fragp->fr_fix;
4227       fix = 0;
4228
4229       if (count & 3)
4230         {
4231           fix = count & 3;
4232           memset (p, 0, fix);
4233           p += fix;
4234           count -= fix;
4235         }
4236
4237       if (SPARC_OPCODE_ARCH_V9_P (max_architecture) && count > 8)
4238         {
4239           unsigned wval = (0x30680000 | count >> 2); /* ba,a,pt %xcc, 1f  */
4240           if (INSN_BIG_ENDIAN)
4241             number_to_chars_bigendian (p, wval, 4);
4242           else
4243             number_to_chars_littleendian (p, wval, 4);
4244           p += 4;
4245           count -= 4;
4246           fix += 4;
4247         }
4248
4249       if (INSN_BIG_ENDIAN)
4250         number_to_chars_bigendian (p, 0x01000000, 4);
4251       else
4252         number_to_chars_littleendian (p, 0x01000000, 4);
4253
4254       fragp->fr_fix += fix;
4255       fragp->fr_var = 4;
4256       break;
4257
4258     default:
4259       break;
4260     }
4261 }
4262
4263 #ifdef OBJ_ELF
4264 /* Some special processing for a Sparc ELF file.  */
4265
4266 void
4267 sparc_elf_final_processing ()
4268 {
4269   /* Set the Sparc ELF flag bits.  FIXME: There should probably be some
4270      sort of BFD interface for this.  */
4271   if (sparc_arch_size == 64)
4272     {
4273       switch (sparc_memory_model)
4274         {
4275         case MM_RMO:
4276           elf_elfheader (stdoutput)->e_flags |= EF_SPARCV9_RMO;
4277           break;
4278         case MM_PSO:
4279           elf_elfheader (stdoutput)->e_flags |= EF_SPARCV9_PSO;
4280           break;
4281         default:
4282           break;
4283         }
4284     }
4285   else if (current_architecture >= SPARC_OPCODE_ARCH_V9)
4286     elf_elfheader (stdoutput)->e_flags |= EF_SPARC_32PLUS;
4287   if (current_architecture == SPARC_OPCODE_ARCH_V9A)
4288     elf_elfheader (stdoutput)->e_flags |= EF_SPARC_SUN_US1;
4289   else if (current_architecture == SPARC_OPCODE_ARCH_V9B)
4290     elf_elfheader (stdoutput)->e_flags |= EF_SPARC_SUN_US1|EF_SPARC_SUN_US3;
4291 }
4292
4293 void
4294 sparc_cons (exp, size)
4295      expressionS *exp;
4296      int size;
4297 {
4298   char *save;
4299
4300   SKIP_WHITESPACE ();
4301   sparc_cons_special_reloc = NULL;
4302   save = input_line_pointer;
4303   if (input_line_pointer[0] == '%'
4304       && input_line_pointer[1] == 'r'
4305       && input_line_pointer[2] == '_')
4306     {
4307       if (strncmp (input_line_pointer + 3, "disp", 4) == 0)
4308         {
4309           input_line_pointer += 7;
4310           sparc_cons_special_reloc = "disp";
4311         }
4312       else if (strncmp (input_line_pointer + 3, "plt", 3) == 0)
4313         {
4314           if (size != 4 && size != 8)
4315             as_bad (_("Illegal operands: %%r_plt in %d-byte data field"), size);
4316           else
4317             {
4318               input_line_pointer += 6;
4319               sparc_cons_special_reloc = "plt";
4320             }
4321         }
4322       else if (strncmp (input_line_pointer + 3, "tls_dtpoff", 10) == 0)
4323         {
4324           if (size != 4 && size != 8)
4325             as_bad (_("Illegal operands: %%r_tls_dtpoff in %d-byte data field"), size);
4326           else
4327             {
4328               input_line_pointer += 13;
4329               sparc_cons_special_reloc = "tls_dtpoff";
4330             }
4331         }
4332       if (sparc_cons_special_reloc)
4333         {
4334           int bad = 0;
4335
4336           switch (size)
4337             {
4338             case 1:
4339               if (*input_line_pointer != '8')
4340                 bad = 1;
4341               input_line_pointer--;
4342               break;
4343             case 2:
4344               if (input_line_pointer[0] != '1' || input_line_pointer[1] != '6')
4345                 bad = 1;
4346               break;
4347             case 4:
4348               if (input_line_pointer[0] != '3' || input_line_pointer[1] != '2')
4349                 bad = 1;
4350               break;
4351             case 8:
4352               if (input_line_pointer[0] != '6' || input_line_pointer[1] != '4')
4353                 bad = 1;
4354               break;
4355             default:
4356               bad = 1;
4357               break;
4358             }
4359
4360           if (bad)
4361             {
4362               as_bad (_("Illegal operands: Only %%r_%s%d allowed in %d-byte data fields"),
4363                       sparc_cons_special_reloc, size * 8, size);
4364             }
4365           else
4366             {
4367               input_line_pointer += 2;
4368               if (*input_line_pointer != '(')
4369                 {
4370                   as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
4371                           sparc_cons_special_reloc, size * 8);
4372                   bad = 1;
4373                 }
4374             }
4375
4376           if (bad)
4377             {
4378               input_line_pointer = save;
4379               sparc_cons_special_reloc = NULL;
4380             }
4381           else
4382             {
4383               int c;
4384               char *end = ++input_line_pointer;
4385               int npar = 0;
4386
4387               while (! is_end_of_line[(c = *end)])
4388                 {
4389                   if (c == '(')
4390                     npar++;
4391                   else if (c == ')')
4392                     {
4393                       if (!npar)
4394                         break;
4395                       npar--;
4396                     }
4397                   end++;
4398                 }
4399
4400               if (c != ')')
4401                 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
4402                         sparc_cons_special_reloc, size * 8);
4403               else
4404                 {
4405                   *end = '\0';
4406                   expression (exp);
4407                   *end = c;
4408                   if (input_line_pointer != end)
4409                     {
4410                       as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
4411                               sparc_cons_special_reloc, size * 8);
4412                     }
4413                   else
4414                     {
4415                       input_line_pointer++;
4416                       SKIP_WHITESPACE ();
4417                       c = *input_line_pointer;
4418                       if (! is_end_of_line[c] && c != ',')
4419                         as_bad (_("Illegal operands: garbage after %%r_%s%d()"),
4420                                 sparc_cons_special_reloc, size * 8);
4421                     }
4422                 }
4423             }
4424         }
4425     }
4426   if (sparc_cons_special_reloc == NULL)
4427     expression (exp);
4428 }
4429
4430 #endif
4431
4432 /* This is called by emit_expr via TC_CONS_FIX_NEW when creating a
4433    reloc for a cons.  We could use the definition there, except that
4434    we want to handle little endian relocs specially.  */
4435
4436 void
4437 cons_fix_new_sparc (frag, where, nbytes, exp)
4438      fragS *frag;
4439      int where;
4440      unsigned int nbytes;
4441      expressionS *exp;
4442 {
4443   bfd_reloc_code_real_type r;
4444
4445   r = (nbytes == 1 ? BFD_RELOC_8 :
4446        (nbytes == 2 ? BFD_RELOC_16 :
4447         (nbytes == 4 ? BFD_RELOC_32 : BFD_RELOC_64)));
4448
4449   if (target_little_endian_data
4450       && nbytes == 4
4451       && now_seg->flags & SEC_ALLOC)
4452     r = BFD_RELOC_SPARC_REV32;
4453
4454   if (sparc_cons_special_reloc)
4455     {
4456       if (*sparc_cons_special_reloc == 'd')
4457         switch (nbytes)
4458           {
4459           case 1: r = BFD_RELOC_8_PCREL; break;
4460           case 2: r = BFD_RELOC_16_PCREL; break;
4461           case 4: r = BFD_RELOC_32_PCREL; break;
4462           case 8: r = BFD_RELOC_64_PCREL; break;
4463           default: abort ();
4464           }
4465       else if (*sparc_cons_special_reloc == 'p')
4466         switch (nbytes)
4467           {
4468           case 4: r = BFD_RELOC_SPARC_PLT32; break;
4469           case 8: r = BFD_RELOC_SPARC_PLT64; break;
4470           }
4471       else
4472         switch (nbytes)
4473           {
4474           case 4: r = BFD_RELOC_SPARC_TLS_DTPOFF32; break;
4475           case 8: r = BFD_RELOC_SPARC_TLS_DTPOFF64; break;
4476           }
4477     }
4478   else if (sparc_no_align_cons)
4479     {
4480       switch (nbytes)
4481         {
4482         case 2: r = BFD_RELOC_SPARC_UA16; break;
4483         case 4: r = BFD_RELOC_SPARC_UA32; break;
4484         case 8: r = BFD_RELOC_SPARC_UA64; break;
4485         default: abort ();
4486         }
4487    }
4488
4489   fix_new_exp (frag, where, (int) nbytes, exp, 0, r);
4490   sparc_cons_special_reloc = NULL;
4491 }
4492
4493 void
4494 sparc_cfi_frame_initial_instructions ()
4495 {
4496   cfi_add_CFA_def_cfa (14, sparc_arch_size == 64 ? 0x7ff : 0);
4497 }
4498
4499 int
4500 sparc_regname_to_dw2regnum (const char *regname)
4501 {
4502   char *p, *q;
4503
4504   if (!regname[0])
4505     return -1;
4506
4507   q = "goli";
4508   p = strchr (q, regname[0]);
4509   if (p)
4510     {
4511       if (regname[1] < '0' || regname[1] > '8' || regname[2])
4512         return -1;
4513       return (p - q) * 8 + regname[1] - '0';
4514     }
4515   if (regname[0] == 's' && regname[1] == 'p' && !regname[2])
4516     return 14;
4517   if (regname[0] == 'f' && regname[1] == 'p' && !regname[2])
4518     return 30;
4519   if (regname[0] == 'f' || regname[0] == 'r')
4520     {
4521       unsigned int regnum;
4522
4523       regnum = strtoul (regname + 1, &q, 10);
4524       if (p == q || *q)
4525         return -1;
4526       if (regnum >= ((regname[0] == 'f'
4527                       && SPARC_OPCODE_ARCH_V9_P (max_architecture))
4528                      ? 64 : 32))
4529         return -1;
4530       if (regname[0] == 'f')
4531         {
4532           regnum += 32;
4533           if (regnum >= 64 && (regnum & 1))
4534             return -1;
4535         }
4536       return regnum;
4537     }
4538   return -1;
4539 }
4540
4541 void
4542 sparc_cfi_emit_pcrel_expr (expressionS *exp, unsigned int nbytes)
4543 {
4544   sparc_cons_special_reloc = "disp";
4545   sparc_no_align_cons = 1;
4546   emit_expr (exp, nbytes);
4547   sparc_no_align_cons = 0;
4548   sparc_cons_special_reloc = NULL;
4549 }