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