gas/config/tc-hppa.c

   1 /* tc-hppa.c -- Assemble for the PA
   2    Copyright 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 /* HP PA-RISC support was contributed by the Center for Software Science
  24    at the University of Utah.  */
  25
  26 #include "as.h"
  27 #include "safe-ctype.h"
  28 #include "subsegs.h"
  29 #include "dw2gencfi.h"
  30
  31 #include "bfd/libhppa.h"
  32
  33 /* Be careful, this file includes data *declarations*.  */
  34 #include "opcode/hppa.h"
  35
  36 #if defined (OBJ_ELF) && defined (OBJ_SOM)
  37 error only one of OBJ_ELF and OBJ_SOM can be defined
  38 #endif
  39
  40 /* If we are using ELF, then we probably can support dwarf2 debug
  41    records.  Furthermore, if we are supporting dwarf2 debug records,
  42    then we want to use the assembler support for compact line numbers.  */
  43 #ifdef OBJ_ELF
  44 #include "dwarf2dbg.h"
  45
  46 /* A "convenient" place to put object file dependencies which do
  47    not need to be seen outside of tc-hppa.c.  */
  48
  49 /* Object file formats specify relocation types.  */
  50 typedef enum elf_hppa_reloc_type reloc_type;
  51
  52 /* Object file formats specify BFD symbol types.  */
  53 typedef elf_symbol_type obj_symbol_type;
  54 #define symbol_arg_reloc_info(sym)\
  55   (((obj_symbol_type *) symbol_get_bfdsym (sym))->tc_data.hppa_arg_reloc)
  56
  57 #if TARGET_ARCH_SIZE == 64
  58 /* How to generate a relocation.  */
  59 #define hppa_gen_reloc_type _bfd_elf64_hppa_gen_reloc_type
  60 #define elf_hppa_reloc_final_type elf64_hppa_reloc_final_type
  61 #else
  62 #define hppa_gen_reloc_type _bfd_elf32_hppa_gen_reloc_type
  63 #define elf_hppa_reloc_final_type elf32_hppa_reloc_final_type
  64 #endif
  65
  66 /* ELF objects can have versions, but apparently do not have anywhere
  67    to store a copyright string.  */
  68 #define obj_version obj_elf_version
  69 #define obj_copyright obj_elf_version
  70
  71 #define UNWIND_SECTION_NAME ".PARISC.unwind"
  72 #endif /* OBJ_ELF */
  73
  74 #ifdef OBJ_SOM
  75 /* Names of various debugging spaces/subspaces.  */
  76 #define GDB_DEBUG_SPACE_NAME "$GDB_DEBUG$"
  77 #define GDB_STRINGS_SUBSPACE_NAME "$GDB_STRINGS$"
  78 #define GDB_SYMBOLS_SUBSPACE_NAME "$GDB_SYMBOLS$"
  79 #define UNWIND_SECTION_NAME "$UNWIND$"
  80
  81 /* Object file formats specify relocation types.  */
  82 typedef int reloc_type;
  83
  84 /* SOM objects can have both a version string and a copyright string.  */
  85 #define obj_version obj_som_version
  86 #define obj_copyright obj_som_copyright
  87
  88 /* How to generate a relocation.  */
  89 #define hppa_gen_reloc_type hppa_som_gen_reloc_type
  90
  91 /* Object file formats specify BFD symbol types.  */
  92 typedef som_symbol_type obj_symbol_type;
  93 #define symbol_arg_reloc_info(sym)\
  94   (((obj_symbol_type *) symbol_get_bfdsym (sym))->tc_data.ap.hppa_arg_reloc)
  95
  96 /* This apparently isn't in older versions of hpux reloc.h.  */
  97 #ifndef R_DLT_REL
  98 #define R_DLT_REL 0x78
  99 #endif
 100
 101 #ifndef R_N0SEL
 102 #define R_N0SEL 0xd8
 103 #endif
 104
 105 #ifndef R_N1SEL
 106 #define R_N1SEL 0xd9
 107 #endif
 108 #endif /* OBJ_SOM */
 109
 110 #if TARGET_ARCH_SIZE == 64
 111 #define DEFAULT_LEVEL 25
 112 #else
 113 #define DEFAULT_LEVEL 10
 114 #endif
 115
 116 /* Various structures and types used internally in tc-hppa.c.  */
 117
 118 /* Unwind table and descriptor.  FIXME: Sync this with GDB version.  */
 119
 120 struct unwind_desc
 121   {
 122     unsigned int cannot_unwind:1;
 123     unsigned int millicode:1;
 124     unsigned int millicode_save_rest:1;
 125     unsigned int region_desc:2;
 126     unsigned int save_sr:2;
 127     unsigned int entry_fr:4;
 128     unsigned int entry_gr:5;
 129     unsigned int args_stored:1;
 130     unsigned int call_fr:5;
 131     unsigned int call_gr:5;
 132     unsigned int save_sp:1;
 133     unsigned int save_rp:1;
 134     unsigned int save_rp_in_frame:1;
 135     unsigned int extn_ptr_defined:1;
 136     unsigned int cleanup_defined:1;
 137
 138     unsigned int hpe_interrupt_marker:1;
 139     unsigned int hpux_interrupt_marker:1;
 140     unsigned int reserved:3;
 141     unsigned int frame_size:27;
 142   };
 143
 144 /* We can't rely on compilers placing bitfields in any particular
 145    place, so use these macros when dumping unwind descriptors to
 146    object files.  */
 147 #define UNWIND_LOW32(U) \
 148   (((U)->cannot_unwind << 31)           \
 149    | ((U)->millicode << 30)             \
 150    | ((U)->millicode_save_rest << 29)   \
 151    | ((U)->region_desc << 27)           \
 152    | ((U)->save_sr << 25)               \
 153    | ((U)->entry_fr << 21)              \
 154    | ((U)->entry_gr << 16)              \
 155    | ((U)->args_stored << 15)           \
 156    | ((U)->call_fr << 10)               \
 157    | ((U)->call_gr << 5)                \
 158    | ((U)->save_sp << 4)                \
 159    | ((U)->save_rp << 3)                \
 160    | ((U)->save_rp_in_frame << 2)       \
 161    | ((U)->extn_ptr_defined << 1)       \
 162    | ((U)->cleanup_defined << 0))
 163
 164 #define UNWIND_HIGH32(U) \
 165   (((U)->hpe_interrupt_marker << 31)    \
 166    | ((U)->hpux_interrupt_marker << 30) \
 167    | ((U)->frame_size << 0))
 168
 169 struct unwind_table
 170   {
 171     /* Starting and ending offsets of the region described by
 172        descriptor.  */
 173     unsigned int start_offset;
 174     unsigned int end_offset;
 175     struct unwind_desc descriptor;
 176   };
 177
 178 /* This structure is used by the .callinfo, .enter, .leave pseudo-ops to
 179    control the entry and exit code they generate. It is also used in
 180    creation of the correct stack unwind descriptors.
 181
 182    NOTE:  GAS does not support .enter and .leave for the generation of
 183    prologues and epilogues.  FIXME.
 184
 185    The fields in structure roughly correspond to the arguments available on the
 186    .callinfo pseudo-op.  */
 187
 188 struct call_info
 189   {
 190     /* The unwind descriptor being built.  */
 191     struct unwind_table ci_unwind;
 192
 193     /* Name of this function.  */
 194     symbolS *start_symbol;
 195
 196     /* (temporary) symbol used to mark the end of this function.  */
 197     symbolS *end_symbol;
 198
 199     /* Next entry in the chain.  */
 200     struct call_info *ci_next;
 201   };
 202
 203 /* Operand formats for FP instructions.   Note not all FP instructions
 204    allow all four formats to be used (for example fmpysub only allows
 205    SGL and DBL).  */
 206 typedef enum
 207   {
 208     SGL, DBL, ILLEGAL_FMT, QUAD, W, UW, DW, UDW, QW, UQW
 209   }
 210 fp_operand_format;
 211
 212 /* This fully describes the symbol types which may be attached to
 213    an EXPORT or IMPORT directive.  Only SOM uses this formation
 214    (ELF has no need for it).  */
 215 typedef enum
 216   {
 217     SYMBOL_TYPE_UNKNOWN,
 218     SYMBOL_TYPE_ABSOLUTE,
 219     SYMBOL_TYPE_CODE,
 220     SYMBOL_TYPE_DATA,
 221     SYMBOL_TYPE_ENTRY,
 222     SYMBOL_TYPE_MILLICODE,
 223     SYMBOL_TYPE_PLABEL,
 224     SYMBOL_TYPE_PRI_PROG,
 225     SYMBOL_TYPE_SEC_PROG,
 226   }
 227 pa_symbol_type;
 228
 229 /* This structure contains information needed to assemble
 230    individual instructions.  */
 231 struct pa_it
 232   {
 233     /* Holds the opcode after parsing by pa_ip.  */
 234     unsigned long opcode;
 235
 236     /* Holds an expression associated with the current instruction.  */
 237     expressionS exp;
 238
 239     /* Does this instruction use PC-relative addressing.  */
 240     int pcrel;
 241
 242     /* Floating point formats for operand1 and operand2.  */
 243     fp_operand_format fpof1;
 244     fp_operand_format fpof2;
 245
 246     /* Whether or not we saw a truncation request on an fcnv insn.  */
 247     int trunc;
 248
 249     /* Holds the field selector for this instruction
 250        (for example L%, LR%, etc).  */
 251     long field_selector;
 252
 253     /* Holds any argument relocation bits associated with this
 254        instruction.  (instruction should be some sort of call).  */
 255     unsigned int arg_reloc;
 256
 257     /* The format specification for this instruction.  */
 258     int format;
 259
 260     /* The relocation (if any) associated with this instruction.  */
 261     reloc_type reloc;
 262   };
 263
 264 /* PA-89 floating point registers are arranged like this:
 265
 266    +--------------+--------------+
 267    |   0 or 16L   |  16 or 16R   |
 268    +--------------+--------------+
 269    |   1 or 17L   |  17 or 17R   |
 270    +--------------+--------------+
 271    |              |              |
 272
 273    .              .              .
 274    .              .              .
 275    .              .              .
 276
 277    |              |              |
 278    +--------------+--------------+
 279    |  14 or 30L   |  30 or 30R   |
 280    +--------------+--------------+
 281    |  15 or 31L   |  31 or 31R   |
 282    +--------------+--------------+  */
 283
 284 /* Additional information needed to build argument relocation stubs.  */
 285 struct call_desc
 286   {
 287     /* The argument relocation specification.  */
 288     unsigned int arg_reloc;
 289
 290     /* Number of arguments.  */
 291     unsigned int arg_count;
 292   };
 293
 294 #ifdef OBJ_SOM
 295 /* This structure defines an entry in the subspace dictionary
 296    chain.  */
 297
 298 struct subspace_dictionary_chain
 299   {
 300     /* Nonzero if this space has been defined by the user code.  */
 301     unsigned int ssd_defined;
 302
 303     /* Name of this subspace.  */
 304     char *ssd_name;
 305
 306     /* GAS segment and subsegment associated with this subspace.  */
 307     asection *ssd_seg;
 308     int ssd_subseg;
 309
 310     /* Next space in the subspace dictionary chain.  */
 311     struct subspace_dictionary_chain *ssd_next;
 312   };
 313
 314 typedef struct subspace_dictionary_chain ssd_chain_struct;
 315
 316 /* This structure defines an entry in the subspace dictionary
 317    chain.  */
 318
 319 struct space_dictionary_chain
 320   {
 321     /* Nonzero if this space has been defined by the user code or
 322        as a default space.  */
 323     unsigned int sd_defined;
 324
 325     /* Nonzero if this spaces has been defined by the user code.  */
 326     unsigned int sd_user_defined;
 327
 328     /* The space number (or index).  */
 329     unsigned int sd_spnum;
 330
 331     /* The name of this subspace.  */
 332     char *sd_name;
 333
 334     /* GAS segment to which this subspace corresponds.  */
 335     asection *sd_seg;
 336
 337     /* Current subsegment number being used.  */
 338     int sd_last_subseg;
 339
 340     /* The chain of subspaces contained within this space.  */
 341     ssd_chain_struct *sd_subspaces;
 342
 343     /* The next entry in the space dictionary chain.  */
 344     struct space_dictionary_chain *sd_next;
 345   };
 346
 347 typedef struct space_dictionary_chain sd_chain_struct;
 348
 349 /* This structure defines attributes of the default subspace
 350    dictionary entries.  */
 351
 352 struct default_subspace_dict
 353   {
 354     /* Name of the subspace.  */
 355     char *name;
 356
 357     /* FIXME.  Is this still needed?  */
 358     char defined;
 359
 360     /* Nonzero if this subspace is loadable.  */
 361     char loadable;
 362
 363     /* Nonzero if this subspace contains only code.  */
 364     char code_only;
 365
 366     /* Nonzero if this is a comdat subspace.  */
 367     char comdat;
 368
 369     /* Nonzero if this is a common subspace.  */
 370     char common;
 371
 372     /* Nonzero if this is a common subspace which allows symbols
 373        to be multiply defined.  */
 374     char dup_common;
 375
 376     /* Nonzero if this subspace should be zero filled.  */
 377     char zero;
 378
 379     /* Sort key for this subspace.  */
 380     unsigned char sort;
 381
 382     /* Access control bits for this subspace.  Can represent RWX access
 383        as well as privilege level changes for gateways.  */
 384     int access;
 385
 386     /* Index of containing space.  */
 387     int space_index;
 388
 389     /* Alignment (in bytes) of this subspace.  */
 390     int alignment;
 391
 392     /* Quadrant within space where this subspace should be loaded.  */
 393     int quadrant;
 394
 395     /* An index into the default spaces array.  */
 396     int def_space_index;
 397
 398     /* Subsegment associated with this subspace.  */
 399     subsegT subsegment;
 400   };
 401
 402 /* This structure defines attributes of the default space
 403    dictionary entries.  */
 404
 405 struct default_space_dict
 406   {
 407     /* Name of the space.  */
 408     char *name;
 409
 410     /* Space number.  It is possible to identify spaces within
 411        assembly code numerically!  */
 412     int spnum;
 413
 414     /* Nonzero if this space is loadable.  */
 415     char loadable;
 416
 417     /* Nonzero if this space is "defined".  FIXME is still needed */
 418     char defined;
 419
 420     /* Nonzero if this space can not be shared.  */
 421     char private;
 422
 423     /* Sort key for this space.  */
 424     unsigned char sort;
 425
 426     /* Segment associated with this space.  */
 427     asection *segment;
 428   };
 429 #endif
 430
 431 /* Structure for previous label tracking.  Needed so that alignments,
 432    callinfo declarations, etc can be easily attached to a particular
 433    label.  */
 434 typedef struct label_symbol_struct
 435   {
 436     struct symbol *lss_label;
 437 #ifdef OBJ_SOM
 438     sd_chain_struct *lss_space;
 439 #endif
 440 #ifdef OBJ_ELF
 441     segT lss_segment;
 442 #endif
 443     struct label_symbol_struct *lss_next;
 444   }
 445 label_symbol_struct;
 446
 447 /* Extra information needed to perform fixups (relocations) on the PA.  */
 448 struct hppa_fix_struct
 449   {
 450     /* The field selector.  */
 451     enum hppa_reloc_field_selector_type_alt fx_r_field;
 452
 453     /* Type of fixup.  */
 454     int fx_r_type;
 455
 456     /* Format of fixup.  */
 457     int fx_r_format;
 458
 459     /* Argument relocation bits.  */
 460     unsigned int fx_arg_reloc;
 461
 462     /* The segment this fixup appears in.  */
 463     segT segment;
 464   };
 465
 466 /* Structure to hold information about predefined registers.  */
 467
 468 struct pd_reg
 469   {
 470     char *name;
 471     int value;
 472   };
 473
 474 /* This structure defines the mapping from a FP condition string
 475    to a condition number which can be recorded in an instruction.  */
 476 struct fp_cond_map
 477   {
 478     char *string;
 479     int cond;
 480   };
 481
 482 /* This structure defines a mapping from a field selector
 483    string to a field selector type.  */
 484 struct selector_entry
 485   {
 486     char *prefix;
 487     int field_selector;
 488   };
 489
 490 /* Prototypes for functions local to tc-hppa.c.  */
 491
 492 #ifdef OBJ_SOM
 493 static void pa_check_current_space_and_subspace (void);
 494 #endif
 495
 496 #if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
 497 static void pa_text (int);
 498 static void pa_data (int);
 499 static void pa_comm (int);
 500 #endif
 501 #ifdef OBJ_SOM
 502 static int exact_log2 (int);
 503 static void pa_compiler (int);
 504 static void pa_align (int);
 505 static void pa_space (int);
 506 static void pa_spnum (int);
 507 static void pa_subspace (int);
 508 static sd_chain_struct *create_new_space (char *, int, int,
 509                                                   int, int, int,
 510                                                   asection *, int);
 511 static ssd_chain_struct *create_new_subspace (sd_chain_struct *,
 512                                                       char *, int, int,
 513                                                       int, int, int, int,
 514                                                       int, int, int, int,
 515                                                       int, asection *);
 516 static ssd_chain_struct *update_subspace (sd_chain_struct *,
 517                                                   char *, int, int, int,
 518                                                   int, int, int, int,
 519                                                   int, int, int, int,
 520                                                   asection *);
 521 static sd_chain_struct *is_defined_space (char *);
 522 static ssd_chain_struct *is_defined_subspace (char *);
 523 static sd_chain_struct *pa_segment_to_space (asection *);
 524 static ssd_chain_struct *pa_subsegment_to_subspace (asection *,
 525                                                             subsegT);
 526 static sd_chain_struct *pa_find_space_by_number (int);
 527 static unsigned int pa_subspace_start (sd_chain_struct *, int);
 528 static sd_chain_struct *pa_parse_space_stmt (char *, int);
 529 #endif
 530
 531 /* File and globally scoped variable declarations.  */
 532
 533 #ifdef OBJ_SOM
 534 /* Root and final entry in the space chain.  */
 535 static sd_chain_struct *space_dict_root;
 536 static sd_chain_struct *space_dict_last;
 537
 538 /* The current space and subspace.  */
 539 static sd_chain_struct *current_space;
 540 static ssd_chain_struct *current_subspace;
 541 #endif
 542
 543 /* Root of the call_info chain.  */
 544 static struct call_info *call_info_root;
 545
 546 /* The last call_info (for functions) structure
 547    seen so it can be associated with fixups and
 548    function labels.  */
 549 static struct call_info *last_call_info;
 550
 551 /* The last call description (for actual calls).  */
 552 static struct call_desc last_call_desc;
 553
 554 /* handle of the OPCODE hash table */
 555 static struct hash_control *op_hash = NULL;
 556
 557 /* These characters can be suffixes of opcode names and they may be
 558    followed by meaningful whitespace.  We don't include `,' and `!'
 559    as they never appear followed by meaningful whitespace.  */
 560 const char hppa_symbol_chars[] = "*?=<>";
 561
 562 /* This array holds the chars that only start a comment at the beginning of
 563    a line.  If the line seems to have the form '# 123 filename'
 564    .line and .file directives will appear in the pre-processed output.
 565
 566    Note that input_file.c hand checks for '#' at the beginning of the
 567    first line of the input file.  This is because the compiler outputs
 568    #NO_APP at the beginning of its output.
 569
 570    Also note that C style comments will always work.  */
 571 const char line_comment_chars[] = "#";
 572
 573 /* This array holds the chars that always start a comment.  If the
 574    pre-processor is disabled, these aren't very useful.  */
 575 const char comment_chars[] = ";";
 576
 577 /* This array holds the characters which act as line separators.  */
 578 const char line_separator_chars[] = "!";
 579
 580 /* Chars that can be used to separate mant from exp in floating point nums.  */
 581 const char EXP_CHARS[] = "eE";
 582
 583 /* Chars that mean this number is a floating point constant.
 584    As in 0f12.456 or 0d1.2345e12.
 585
 586    Be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
 587    changed in read.c.  Ideally it shouldn't have to know about it
 588    at all, but nothing is ideal around here.  */
 589 const char FLT_CHARS[] = "rRsSfFdDxXpP";
 590
 591 static struct pa_it the_insn;
 592
 593 /* Points to the end of an expression just parsed by get_expression
 594    and friends.  FIXME.  This shouldn't be handled with a file-global
 595    variable.  */
 596 static char *expr_end;
 597
 598 /* Nonzero if a .callinfo appeared within the current procedure.  */
 599 static int callinfo_found;
 600
 601 /* Nonzero if the assembler is currently within a .entry/.exit pair.  */
 602 static int within_entry_exit;
 603
 604 /* Nonzero if the assembler is currently within a procedure definition.  */
 605 static int within_procedure;
 606
 607 /* Handle on structure which keep track of the last symbol
 608    seen in each subspace.  */
 609 static label_symbol_struct *label_symbols_rootp = NULL;
 610
 611 /* Holds the last field selector.  */
 612 static int hppa_field_selector;
 613
 614 /* Nonzero when strict matching is enabled.  Zero otherwise.
 615
 616    Each opcode in the table has a flag which indicates whether or
 617    not strict matching should be enabled for that instruction.
 618
 619    Mainly, strict causes errors to be ignored when a match failure
 620    occurs.  However, it also affects the parsing of register fields
 621    by pa_parse_number.  */
 622 static int strict;
 623
 624 /* pa_parse_number returns values in `pa_number'.  Mostly
 625    pa_parse_number is used to return a register number, with floating
 626    point registers being numbered from FP_REG_BASE upwards.
 627    The bit specified with FP_REG_RSEL is set if the floating point
 628    register has a `r' suffix.  */
 629 #define FP_REG_BASE 64
 630 #define FP_REG_RSEL 128
 631 static int pa_number;
 632
 633 #ifdef OBJ_SOM
 634 /* A dummy bfd symbol so that all relocations have symbols of some kind.  */
 635 static symbolS *dummy_symbol;
 636 #endif
 637
 638 /* Nonzero if errors are to be printed.  */
 639 static int print_errors = 1;
 640
 641 /* List of registers that are pre-defined:
 642
 643    Each general register has one predefined name of the form
 644    %r<REGNUM> which has the value <REGNUM>.
 645
 646    Space and control registers are handled in a similar manner,
 647    but use %sr<REGNUM> and %cr<REGNUM> as their predefined names.
 648
 649    Likewise for the floating point registers, but of the form
 650    %fr<REGNUM>.  Floating point registers have additional predefined
 651    names with 'L' and 'R' suffixes (e.g. %fr19L, %fr19R) which
 652    again have the value <REGNUM>.
 653
 654    Many registers also have synonyms:
 655
 656    %r26 - %r23 have %arg0 - %arg3 as synonyms
 657    %r28 - %r29 have %ret0 - %ret1 as synonyms
 658    %fr4 - %fr7 have %farg0 - %farg3 as synonyms
 659    %r30 has %sp as a synonym
 660    %r27 has %dp as a synonym
 661    %r2  has %rp as a synonym
 662
 663    Almost every control register has a synonym; they are not listed
 664    here for brevity.
 665
 666    The table is sorted. Suitable for searching by a binary search.  */
 667
 668 static const struct pd_reg pre_defined_registers[] =
 669 {
 670   {"%arg0",  26},
 671   {"%arg1",  25},
 672   {"%arg2",  24},
 673   {"%arg3",  23},
 674   {"%cr0",    0},
 675   {"%cr10",  10},
 676   {"%cr11",  11},
 677   {"%cr12",  12},
 678   {"%cr13",  13},
 679   {"%cr14",  14},
 680   {"%cr15",  15},
 681   {"%cr16",  16},
 682   {"%cr17",  17},
 683   {"%cr18",  18},
 684   {"%cr19",  19},
 685   {"%cr20",  20},
 686   {"%cr21",  21},
 687   {"%cr22",  22},
 688   {"%cr23",  23},
 689   {"%cr24",  24},
 690   {"%cr25",  25},
 691   {"%cr26",  26},
 692   {"%cr27",  27},
 693   {"%cr28",  28},
 694   {"%cr29",  29},
 695   {"%cr30",  30},
 696   {"%cr31",  31},
 697   {"%cr8",    8},
 698   {"%cr9",    9},
 699   {"%dp",    27},
 700   {"%eiem",  15},
 701   {"%eirr",  23},
 702   {"%farg0",  4 + FP_REG_BASE},
 703   {"%farg1",  5 + FP_REG_BASE},
 704   {"%farg2",  6 + FP_REG_BASE},
 705   {"%farg3",  7 + FP_REG_BASE},
 706   {"%fr0",    0 + FP_REG_BASE},
 707   {"%fr0l",   0 + FP_REG_BASE},
 708   {"%fr0r",   0 + FP_REG_BASE + FP_REG_RSEL},
 709   {"%fr1",    1 + FP_REG_BASE},
 710   {"%fr10",  10 + FP_REG_BASE},
 711   {"%fr10l", 10 + FP_REG_BASE},
 712   {"%fr10r", 10 + FP_REG_BASE + FP_REG_RSEL},
 713   {"%fr11",  11 + FP_REG_BASE},
 714   {"%fr11l", 11 + FP_REG_BASE},
 715   {"%fr11r", 11 + FP_REG_BASE + FP_REG_RSEL},
 716   {"%fr12",  12 + FP_REG_BASE},
 717   {"%fr12l", 12 + FP_REG_BASE},
 718   {"%fr12r", 12 + FP_REG_BASE + FP_REG_RSEL},
 719   {"%fr13",  13 + FP_REG_BASE},
 720   {"%fr13l", 13 + FP_REG_BASE},
 721   {"%fr13r", 13 + FP_REG_BASE + FP_REG_RSEL},
 722   {"%fr14",  14 + FP_REG_BASE},
 723   {"%fr14l", 14 + FP_REG_BASE},
 724   {"%fr14r", 14 + FP_REG_BASE + FP_REG_RSEL},
 725   {"%fr15",  15 + FP_REG_BASE},
 726   {"%fr15l", 15 + FP_REG_BASE},
 727   {"%fr15r", 15 + FP_REG_BASE + FP_REG_RSEL},
 728   {"%fr16",  16 + FP_REG_BASE},
 729   {"%fr16l", 16 + FP_REG_BASE},
 730   {"%fr16r", 16 + FP_REG_BASE + FP_REG_RSEL},
 731   {"%fr17",  17 + FP_REG_BASE},
 732   {"%fr17l", 17 + FP_REG_BASE},
 733   {"%fr17r", 17 + FP_REG_BASE + FP_REG_RSEL},
 734   {"%fr18",  18 + FP_REG_BASE},
 735   {"%fr18l", 18 + FP_REG_BASE},
 736   {"%fr18r", 18 + FP_REG_BASE + FP_REG_RSEL},
 737   {"%fr19",  19 + FP_REG_BASE},
 738   {"%fr19l", 19 + FP_REG_BASE},
 739   {"%fr19r", 19 + FP_REG_BASE + FP_REG_RSEL},
 740   {"%fr1l",   1 + FP_REG_BASE},
 741   {"%fr1r",   1 + FP_REG_BASE + FP_REG_RSEL},
 742   {"%fr2",    2 + FP_REG_BASE},
 743   {"%fr20",  20 + FP_REG_BASE},
 744   {"%fr20l", 20 + FP_REG_BASE},
 745   {"%fr20r", 20 + FP_REG_BASE + FP_REG_RSEL},
 746   {"%fr21",  21 + FP_REG_BASE},
 747   {"%fr21l", 21 + FP_REG_BASE},
 748   {"%fr21r", 21 + FP_REG_BASE + FP_REG_RSEL},
 749   {"%fr22",  22 + FP_REG_BASE},
 750   {"%fr22l", 22 + FP_REG_BASE},
 751   {"%fr22r", 22 + FP_REG_BASE + FP_REG_RSEL},
 752   {"%fr23",  23 + FP_REG_BASE},
 753   {"%fr23l", 23 + FP_REG_BASE},
 754   {"%fr23r", 23 + FP_REG_BASE + FP_REG_RSEL},
 755   {"%fr24",  24 + FP_REG_BASE},
 756   {"%fr24l", 24 + FP_REG_BASE},
 757   {"%fr24r", 24 + FP_REG_BASE + FP_REG_RSEL},
 758   {"%fr25",  25 + FP_REG_BASE},
 759   {"%fr25l", 25 + FP_REG_BASE},
 760   {"%fr25r", 25 + FP_REG_BASE + FP_REG_RSEL},
 761   {"%fr26",  26 + FP_REG_BASE},
 762   {"%fr26l", 26 + FP_REG_BASE},
 763   {"%fr26r", 26 + FP_REG_BASE + FP_REG_RSEL},
 764   {"%fr27",  27 + FP_REG_BASE},
 765   {"%fr27l", 27 + FP_REG_BASE},
 766   {"%fr27r", 27 + FP_REG_BASE + FP_REG_RSEL},
 767   {"%fr28",  28 + FP_REG_BASE},
 768   {"%fr28l", 28 + FP_REG_BASE},
 769   {"%fr28r", 28 + FP_REG_BASE + FP_REG_RSEL},
 770   {"%fr29",  29 + FP_REG_BASE},
 771   {"%fr29l", 29 + FP_REG_BASE},
 772   {"%fr29r", 29 + FP_REG_BASE + FP_REG_RSEL},
 773   {"%fr2l",   2 + FP_REG_BASE},
 774   {"%fr2r",   2 + FP_REG_BASE + FP_REG_RSEL},
 775   {"%fr3",    3 + FP_REG_BASE},
 776   {"%fr30",  30 + FP_REG_BASE},
 777   {"%fr30l", 30 + FP_REG_BASE},
 778   {"%fr30r", 30 + FP_REG_BASE + FP_REG_RSEL},
 779   {"%fr31",  31 + FP_REG_BASE},
 780   {"%fr31l", 31 + FP_REG_BASE},
 781   {"%fr31r", 31 + FP_REG_BASE + FP_REG_RSEL},
 782   {"%fr3l",   3 + FP_REG_BASE},
 783   {"%fr3r",   3 + FP_REG_BASE + FP_REG_RSEL},
 784   {"%fr4",    4 + FP_REG_BASE},
 785   {"%fr4l",   4 + FP_REG_BASE},
 786   {"%fr4r",   4 + FP_REG_BASE + FP_REG_RSEL},
 787   {"%fr5",    5 + FP_REG_BASE},
 788   {"%fr5l",   5 + FP_REG_BASE},
 789   {"%fr5r",   5 + FP_REG_BASE + FP_REG_RSEL},
 790   {"%fr6",    6 + FP_REG_BASE},
 791   {"%fr6l",   6 + FP_REG_BASE},
 792   {"%fr6r",   6 + FP_REG_BASE + FP_REG_RSEL},
 793   {"%fr7",    7 + FP_REG_BASE},
 794   {"%fr7l",   7 + FP_REG_BASE},
 795   {"%fr7r",   7 + FP_REG_BASE + FP_REG_RSEL},
 796   {"%fr8",    8 + FP_REG_BASE},
 797   {"%fr8l",   8 + FP_REG_BASE},
 798   {"%fr8r",   8 + FP_REG_BASE + FP_REG_RSEL},
 799   {"%fr9",    9 + FP_REG_BASE},
 800   {"%fr9l",   9 + FP_REG_BASE},
 801   {"%fr9r",   9 + FP_REG_BASE + FP_REG_RSEL},
 802   {"%fret",   4},
 803   {"%hta",   25},
 804   {"%iir",   19},
 805   {"%ior",   21},
 806   {"%ipsw",  22},
 807   {"%isr",   20},
 808   {"%itmr",  16},
 809   {"%iva",   14},
 810 #if TARGET_ARCH_SIZE == 64
 811   {"%mrp",    2},
 812 #else
 813   {"%mrp",   31},
 814 #endif
 815   {"%pcoq",  18},
 816   {"%pcsq",  17},
 817   {"%pidr1",  8},
 818   {"%pidr2",  9},
 819   {"%pidr3", 12},
 820   {"%pidr4", 13},
 821   {"%ppda",  24},
 822   {"%r0",     0},
 823   {"%r1",     1},
 824   {"%r10",   10},
 825   {"%r11",   11},
 826   {"%r12",   12},
 827   {"%r13",   13},
 828   {"%r14",   14},
 829   {"%r15",   15},
 830   {"%r16",   16},
 831   {"%r17",   17},
 832   {"%r18",   18},
 833   {"%r19",   19},
 834   {"%r2",     2},
 835   {"%r20",   20},
 836   {"%r21",   21},
 837   {"%r22",   22},
 838   {"%r23",   23},
 839   {"%r24",   24},
 840   {"%r25",   25},
 841   {"%r26",   26},
 842   {"%r27",   27},
 843   {"%r28",   28},
 844   {"%r29",   29},
 845   {"%r3",     3},
 846   {"%r30",   30},
 847   {"%r31",   31},
 848   {"%r4",     4},
 849   {"%r5",     5},
 850   {"%r6",     6},
 851   {"%r7",     7},
 852   {"%r8",     8},
 853   {"%r9",     9},
 854   {"%rctr",   0},
 855   {"%ret0",  28},
 856   {"%ret1",  29},
 857   {"%rp",     2},
 858   {"%sar",   11},
 859   {"%sp",    30},
 860   {"%sr0",    0},
 861   {"%sr1",    1},
 862   {"%sr2",    2},
 863   {"%sr3",    3},
 864   {"%sr4",    4},
 865   {"%sr5",    5},
 866   {"%sr6",    6},
 867   {"%sr7",    7},
 868   {"%t1",    22},
 869   {"%t2",    21},
 870   {"%t3",    20},
 871   {"%t4",    19},
 872   {"%tf1",   11},
 873   {"%tf2",   10},
 874   {"%tf3",    9},
 875   {"%tf4",    8},
 876   {"%tr0",   24},
 877   {"%tr1",   25},
 878   {"%tr2",   26},
 879   {"%tr3",   27},
 880   {"%tr4",   28},
 881   {"%tr5",   29},
 882   {"%tr6",   30},
 883   {"%tr7",   31}
 884 };
 885
 886 /* This table is sorted by order of the length of the string. This is
 887    so we check for <> before we check for <. If we had a <> and checked
 888    for < first, we would get a false match.  */
 889 static const struct fp_cond_map fp_cond_map[] =
 890 {
 891   {"false?", 0},
 892   {"false", 1},
 893   {"true?", 30},
 894   {"true", 31},
 895   {"!<=>", 3},
 896   {"!?>=", 8},
 897   {"!?<=", 16},
 898   {"!<>", 7},
 899   {"!>=", 11},
 900   {"!?>", 12},
 901   {"?<=", 14},
 902   {"!<=", 19},
 903   {"!?<", 20},
 904   {"?>=", 22},
 905   {"!?=", 24},
 906   {"!=t", 27},
 907   {"<=>", 29},
 908   {"=t", 5},
 909   {"?=", 6},
 910   {"?<", 10},
 911   {"<=", 13},
 912   {"!>", 15},
 913   {"?>", 18},
 914   {">=", 21},
 915   {"!<", 23},
 916   {"<>", 25},
 917   {"!=", 26},
 918   {"!?", 28},
 919   {"?", 2},
 920   {"=", 4},
 921   {"<", 9},
 922   {">", 17}
 923 };
 924
 925 static const struct selector_entry selector_table[] =
 926 {
 927   {"f", e_fsel},
 928   {"l", e_lsel},
 929   {"ld", e_ldsel},
 930   {"lp", e_lpsel},
 931   {"lr", e_lrsel},
 932   {"ls", e_lssel},
 933   {"lt", e_ltsel},
 934   {"ltp", e_ltpsel},
 935   {"n", e_nsel},
 936   {"nl", e_nlsel},
 937   {"nlr", e_nlrsel},
 938   {"p", e_psel},
 939   {"r", e_rsel},
 940   {"rd", e_rdsel},
 941   {"rp", e_rpsel},
 942   {"rr", e_rrsel},
 943   {"rs", e_rssel},
 944   {"rt", e_rtsel},
 945   {"rtp", e_rtpsel},
 946   {"t", e_tsel},
 947 };
 948
 949 #ifdef OBJ_SOM
 950 /* default space and subspace dictionaries */
 951
 952 #define GDB_SYMBOLS     GDB_SYMBOLS_SUBSPACE_NAME
 953 #define GDB_STRINGS     GDB_STRINGS_SUBSPACE_NAME
 954
 955 /* pre-defined subsegments (subspaces) for the HPPA.  */
 956 #define SUBSEG_CODE   0
 957 #define SUBSEG_LIT    1
 958 #define SUBSEG_MILLI  2
 959 #define SUBSEG_DATA   0
 960 #define SUBSEG_BSS    2
 961 #define SUBSEG_UNWIND 3
 962 #define SUBSEG_GDB_STRINGS 0
 963 #define SUBSEG_GDB_SYMBOLS 1
 964
 965 static struct default_subspace_dict pa_def_subspaces[] =
 966 {
 967   {"$CODE$", 1, 1, 1, 0, 0, 0, 0, 24, 0x2c, 0, 8, 0, 0, SUBSEG_CODE},
 968   {"$DATA$", 1, 1, 0, 0, 0, 0, 0, 24, 0x1f, 1, 8, 1, 1, SUBSEG_DATA},
 969   {"$LIT$", 1, 1, 0, 0, 0, 0, 0, 16, 0x2c, 0, 8, 0, 0, SUBSEG_LIT},
 970   {"$MILLICODE$", 1, 1, 0, 0, 0, 0, 0, 8, 0x2c, 0, 8, 0, 0, SUBSEG_MILLI},
 971   {"$BSS$", 1, 1, 0, 0, 0, 0, 1, 80, 0x1f, 1, 8, 1, 1, SUBSEG_BSS},
 972   {NULL, 0, 1, 0, 0, 0, 0, 0, 255, 0x1f, 0, 4, 0, 0, 0}
 973 };
 974
 975 static struct default_space_dict pa_def_spaces[] =
 976 {
 977   {"$TEXT$", 0, 1, 1, 0, 8, ASEC_NULL},
 978   {"$PRIVATE$", 1, 1, 1, 1, 16, ASEC_NULL},
 979   {NULL, 0, 0, 0, 0, 0, ASEC_NULL}
 980 };
 981
 982 /* Misc local definitions used by the assembler.  */
 983
 984 /* These macros are used to maintain spaces/subspaces.  */
 985 #define SPACE_DEFINED(space_chain)      (space_chain)->sd_defined
 986 #define SPACE_USER_DEFINED(space_chain) (space_chain)->sd_user_defined
 987 #define SPACE_SPNUM(space_chain)        (space_chain)->sd_spnum
 988 #define SPACE_NAME(space_chain)         (space_chain)->sd_name
 989
 990 #define SUBSPACE_DEFINED(ss_chain)      (ss_chain)->ssd_defined
 991 #define SUBSPACE_NAME(ss_chain)         (ss_chain)->ssd_name
 992 #endif
 993
 994 /* Return nonzero if the string pointed to by S potentially represents
 995    a right or left half of a FP register  */
 996 #define IS_R_SELECT(S)   (*(S) == 'R' || *(S) == 'r')
 997 #define IS_L_SELECT(S)   (*(S) == 'L' || *(S) == 'l')
 998
 999 /* Store immediate values of shift/deposit/extract functions.  */
1000
1001 #define SAVE_IMMEDIATE(VALUE) \
1002   { \
1003     if (immediate_check) \
1004       { \
1005         if (pos == -1) \
1006           pos = (VALUE); \
1007         else if (len == -1) \
1008           len = (VALUE); \
1009       } \
1010   }
1011
1012 /* Insert FIELD into OPCODE starting at bit START.  Continue pa_ip
1013    main loop after insertion.  */
1014
1015 #define INSERT_FIELD_AND_CONTINUE(OPCODE, FIELD, START) \
1016   { \
1017     ((OPCODE) |= (FIELD) << (START)); \
1018     continue; \
1019   }
1020
1021 /* Simple range checking for FIELD against HIGH and LOW bounds.
1022    IGNORE is used to suppress the error message.  */
1023
1024 #define CHECK_FIELD(FIELD, HIGH, LOW, IGNORE) \
1025   { \
1026     if ((FIELD) > (HIGH) || (FIELD) < (LOW)) \
1027       { \
1028         if (! IGNORE) \
1029           as_bad (_("Field out of range [%d..%d] (%d)."), (LOW), (HIGH), \
1030                   (int) (FIELD));\
1031         break; \
1032       } \
1033   }
1034
1035 /* Variant of CHECK_FIELD for use in md_apply_fix and other places where
1036    the current file and line number are not valid.  */
1037
1038 #define CHECK_FIELD_WHERE(FIELD, HIGH, LOW, FILENAME, LINE) \
1039   { \
1040     if ((FIELD) > (HIGH) || (FIELD) < (LOW)) \
1041       { \
1042         as_bad_where ((FILENAME), (LINE), \
1043                       _("Field out of range [%d..%d] (%d)."), (LOW), (HIGH), \
1044                       (int) (FIELD));\
1045         break; \
1046       } \
1047   }
1048
1049 /* Simple alignment checking for FIELD against ALIGN (a power of two).
1050    IGNORE is used to suppress the error message.  */
1051
1052 #define CHECK_ALIGN(FIELD, ALIGN, IGNORE) \
1053   { \
1054     if ((FIELD) & ((ALIGN) - 1)) \
1055       { \
1056         if (! IGNORE) \
1057           as_bad (_("Field not properly aligned [%d] (%d)."), (ALIGN), \
1058                   (int) (FIELD));\
1059         break; \
1060       } \
1061   }
1062
1063 #define is_DP_relative(exp)                     \
1064   ((exp).X_op == O_subtract                     \
1065    && strcmp (S_GET_NAME ((exp).X_op_symbol), "$global$") == 0)
1066
1067 #define is_SB_relative(exp)                     \
1068   ((exp).X_op == O_subtract                     \
1069    && strcmp (S_GET_NAME ((exp).X_op_symbol), "$segrel$") == 0)
1070
1071 #define is_PC_relative(exp)                     \
1072   ((exp).X_op == O_subtract                     \
1073    && strcmp (S_GET_NAME ((exp).X_op_symbol), "$PIC_pcrel$0") == 0)
1074
1075 #define is_tls_gdidx(exp)                       \
1076   ((exp).X_op == O_subtract                     \
1077    && strcmp (S_GET_NAME ((exp).X_op_symbol), "$tls_gdidx$") == 0)
1078
1079 #define is_tls_ldidx(exp)                       \
1080   ((exp).X_op == O_subtract                     \
1081    && strcmp (S_GET_NAME ((exp).X_op_symbol), "$tls_ldidx$") == 0)
1082
1083 #define is_tls_dtpoff(exp)                      \
1084   ((exp).X_op == O_subtract                     \
1085    && strcmp (S_GET_NAME ((exp).X_op_symbol), "$tls_dtpoff$") == 0)
1086
1087 #define is_tls_ieoff(exp)                       \
1088   ((exp).X_op == O_subtract                     \
1089    && strcmp (S_GET_NAME ((exp).X_op_symbol), "$tls_ieoff$") == 0)
1090
1091 #define is_tls_leoff(exp)                       \
1092   ((exp).X_op == O_subtract                     \
1093    && strcmp (S_GET_NAME ((exp).X_op_symbol), "$tls_leoff$") == 0)
1094
1095 /* We need some complex handling for stabs (sym1 - sym2).  Luckily, we'll
1096    always be able to reduce the expression to a constant, so we don't
1097    need real complex handling yet.  */
1098 #define is_complex(exp)                         \
1099   ((exp).X_op != O_constant && (exp).X_op != O_symbol)
1100
1101 /* Actual functions to implement the PA specific code for the assembler.  */
1102
1103 /* Called before writing the object file.  Make sure entry/exit and
1104    proc/procend pairs match.  */
1105
1106 void
1107 pa_check_eof (void)
1108 {
1109   if (within_entry_exit)
1110     as_fatal (_("Missing .exit\n"));
1111
1112   if (within_procedure)
1113     as_fatal (_("Missing .procend\n"));
1114 }
1115
1116 /* Returns a pointer to the label_symbol_struct for the current space.
1117    or NULL if no label_symbol_struct exists for the current space.  */
1118
1119 static label_symbol_struct *
1120 pa_get_label (void)
1121 {
1122   label_symbol_struct *label_chain;
1123
1124   for (label_chain = label_symbols_rootp;
1125        label_chain;
1126        label_chain = label_chain->lss_next)
1127     {
1128 #ifdef OBJ_SOM
1129     if (current_space == label_chain->lss_space && label_chain->lss_label)
1130       return label_chain;
1131 #endif
1132 #ifdef OBJ_ELF
1133     if (now_seg == label_chain->lss_segment && label_chain->lss_label)
1134       return label_chain;
1135 #endif
1136     }
1137
1138   return NULL;
1139 }
1140
1141 /* Defines a label for the current space.  If one is already defined,
1142    this function will replace it with the new label.  */
1143
1144 void
1145 pa_define_label (symbolS *symbol)
1146 {
1147   label_symbol_struct *label_chain = pa_get_label ();
1148
1149   if (label_chain)
1150     label_chain->lss_label = symbol;
1151   else
1152     {
1153       /* Create a new label entry and add it to the head of the chain.  */
1154       label_chain = xmalloc (sizeof (label_symbol_struct));
1155       label_chain->lss_label = symbol;
1156 #ifdef OBJ_SOM
1157       label_chain->lss_space = current_space;
1158 #endif
1159 #ifdef OBJ_ELF
1160       label_chain->lss_segment = now_seg;
1161 #endif
1162       label_chain->lss_next = NULL;
1163
1164       if (label_symbols_rootp)
1165         label_chain->lss_next = label_symbols_rootp;
1166
1167       label_symbols_rootp = label_chain;
1168     }
1169
1170 #ifdef OBJ_ELF
1171   dwarf2_emit_label (symbol);
1172 #endif
1173 }
1174
1175 /* Removes a label definition for the current space.
1176    If there is no label_symbol_struct entry, then no action is taken.  */
1177
1178 static void
1179 pa_undefine_label (void)
1180 {
1181   label_symbol_struct *label_chain;
1182   label_symbol_struct *prev_label_chain = NULL;
1183
1184   for (label_chain = label_symbols_rootp;
1185        label_chain;
1186        label_chain = label_chain->lss_next)
1187     {
1188       if (1
1189 #ifdef OBJ_SOM
1190           && current_space == label_chain->lss_space && label_chain->lss_label
1191 #endif
1192 #ifdef OBJ_ELF
1193           && now_seg == label_chain->lss_segment && label_chain->lss_label
1194 #endif
1195           )
1196         {
1197           /* Remove the label from the chain and free its memory.  */
1198           if (prev_label_chain)
1199             prev_label_chain->lss_next = label_chain->lss_next;
1200           else
1201             label_symbols_rootp = label_chain->lss_next;
1202
1203           free (label_chain);
1204           break;
1205         }
1206       prev_label_chain = label_chain;
1207     }
1208 }
1209
1210 /* An HPPA-specific version of fix_new.  This is required because the HPPA
1211    code needs to keep track of some extra stuff.  Each call to fix_new_hppa
1212    results in the creation of an instance of an hppa_fix_struct.  An
1213    hppa_fix_struct stores the extra information along with a pointer to the
1214    original fixS.  This is attached to the original fixup via the
1215    tc_fix_data field.  */
1216
1217 static void
1218 fix_new_hppa (fragS *frag,
1219               int where,
1220               int size,
1221               symbolS *add_symbol,
1222               offsetT offset,
1223               expressionS *exp,
1224               int pcrel,
1225               bfd_reloc_code_real_type r_type,
1226               enum hppa_reloc_field_selector_type_alt r_field,
1227               int r_format,
1228               unsigned int arg_reloc,
1229               int unwind_bits ATTRIBUTE_UNUSED)
1230 {
1231   fixS *new_fix;
1232   struct hppa_fix_struct *hppa_fix = obstack_alloc (&notes, sizeof (struct hppa_fix_struct));
1233
1234   if (exp != NULL)
1235     new_fix = fix_new_exp (frag, where, size, exp, pcrel, r_type);
1236   else
1237     new_fix = fix_new (frag, where, size, add_symbol, offset, pcrel, r_type);
1238   new_fix->tc_fix_data = (void *) hppa_fix;
1239   hppa_fix->fx_r_type = r_type;
1240   hppa_fix->fx_r_field = r_field;
1241   hppa_fix->fx_r_format = r_format;
1242   hppa_fix->fx_arg_reloc = arg_reloc;
1243   hppa_fix->segment = now_seg;
1244 #ifdef OBJ_SOM
1245   if (r_type == R_ENTRY || r_type == R_EXIT)
1246     new_fix->fx_offset = unwind_bits;
1247 #endif
1248
1249   /* foo-$global$ is used to access non-automatic storage.  $global$
1250      is really just a marker and has served its purpose, so eliminate
1251      it now so as not to confuse write.c.  Ditto for $PIC_pcrel$0.  */
1252   if (new_fix->fx_subsy
1253       && (strcmp (S_GET_NAME (new_fix->fx_subsy), "$global$") == 0
1254           || strcmp (S_GET_NAME (new_fix->fx_subsy), "$segrel$") == 0
1255           || strcmp (S_GET_NAME (new_fix->fx_subsy), "$PIC_pcrel$0") == 0
1256           || strcmp (S_GET_NAME (new_fix->fx_subsy), "$tls_gdidx$") == 0
1257           || strcmp (S_GET_NAME (new_fix->fx_subsy), "$tls_ldidx$") == 0
1258           || strcmp (S_GET_NAME (new_fix->fx_subsy), "$tls_dtpoff$") == 0
1259           || strcmp (S_GET_NAME (new_fix->fx_subsy), "$tls_ieoff$") == 0
1260           || strcmp (S_GET_NAME (new_fix->fx_subsy), "$tls_leoff$") == 0))
1261     new_fix->fx_subsy = NULL;
1262 }
1263
1264 /* This fix_new is called by cons via TC_CONS_FIX_NEW.
1265    hppa_field_selector is set by the parse_cons_expression_hppa.  */
1266
1267 void
1268 cons_fix_new_hppa (fragS *frag, int where, int size, expressionS *exp)
1269 {
1270   unsigned int rel_type;
1271
1272   /* Get a base relocation type.  */
1273   if (is_DP_relative (*exp))
1274     rel_type = R_HPPA_GOTOFF;
1275   else if (is_PC_relative (*exp))
1276     rel_type = R_HPPA_PCREL_CALL;
1277 #ifdef OBJ_ELF
1278   else if (is_SB_relative (*exp))
1279     rel_type = R_PARISC_SEGREL32;
1280   else if (is_tls_gdidx (*exp))
1281     rel_type = R_PARISC_TLS_GD21L;
1282   else if (is_tls_ldidx (*exp))
1283     rel_type = R_PARISC_TLS_LDM21L;
1284   else if (is_tls_dtpoff (*exp))
1285     rel_type = R_PARISC_TLS_LDO21L;
1286   else if (is_tls_ieoff (*exp))
1287     rel_type = R_PARISC_TLS_IE21L;
1288   else if (is_tls_leoff (*exp))
1289     rel_type = R_PARISC_TLS_LE21L;
1290 #endif
1291   else if (is_complex (*exp))
1292     rel_type = R_HPPA_COMPLEX;
1293   else
1294     rel_type = R_HPPA;
1295
1296   if (hppa_field_selector != e_psel && hppa_field_selector != e_fsel)
1297     {
1298       as_warn (_("Invalid field selector.  Assuming F%%."));
1299       hppa_field_selector = e_fsel;
1300     }
1301
1302   fix_new_hppa (frag, where, size,
1303                 (symbolS *) NULL, (offsetT) 0, exp, 0, rel_type,
1304                 hppa_field_selector, size * 8, 0, 0);
1305
1306   /* Reset field selector to its default state.  */
1307   hppa_field_selector = 0;
1308 }
1309
1310 /* Mark (via expr_end) the end of an expression (I think).  FIXME.  */
1311
1312 static void
1313 get_expression (char *str)
1314 {
1315   char *save_in;
1316   asection *seg;
1317
1318   save_in = input_line_pointer;
1319   input_line_pointer = str;
1320   seg = expression (&the_insn.exp);
1321   if (!(seg == absolute_section
1322         || seg == undefined_section
1323         || SEG_NORMAL (seg)))
1324     {
1325       as_warn (_("Bad segment in expression."));
1326       expr_end = input_line_pointer;
1327       input_line_pointer = save_in;
1328       return;
1329     }
1330   expr_end = input_line_pointer;
1331   input_line_pointer = save_in;
1332 }
1333
1334 /* Parse a PA nullification completer (,n).  Return nonzero if the
1335    completer was found; return zero if no completer was found.  */
1336
1337 static int
1338 pa_parse_nullif (char **s)
1339 {
1340   int nullif;
1341
1342   nullif = 0;
1343   if (**s == ',')
1344     {
1345       *s = *s + 1;
1346       if (strncasecmp (*s, "n", 1) == 0)
1347         nullif = 1;
1348       else
1349         {
1350           as_bad (_("Invalid Nullification: (%c)"), **s);
1351           nullif = 0;
1352         }
1353       *s = *s + 1;
1354     }
1355
1356   return nullif;
1357 }
1358
1359 char *
1360 md_atof (int type, char *litP, int *sizeP)
1361 {
1362   return ieee_md_atof (type, litP, sizeP, TRUE);
1363 }
1364
1365 /* Write out big-endian.  */
1366
1367 void
1368 md_number_to_chars (char *buf, valueT val, int n)
1369 {
1370   number_to_chars_bigendian (buf, val, n);
1371 }
1372
1373 /* Translate internal representation of relocation info to BFD target
1374    format.  */
1375
1376 arelent **
1377 tc_gen_reloc (asection *section, fixS *fixp)
1378 {
1379   arelent *reloc;
1380   struct hppa_fix_struct *hppa_fixp;
1381   static arelent *no_relocs = NULL;
1382   arelent **relocs;
1383   reloc_type **codes;
1384   reloc_type code;
1385   int n_relocs;
1386   int i;
1387
1388   hppa_fixp = (struct hppa_fix_struct *) fixp->tc_fix_data;
1389   if (fixp->fx_addsy == 0)
1390     return &no_relocs;
1391
1392   gas_assert (hppa_fixp != 0);
1393   gas_assert (section != 0);
1394
1395   reloc = xmalloc (sizeof (arelent));
1396
1397   reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
1398   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1399
1400   /* Allow fixup_segment to recognize hand-written pc-relative relocations.
1401      When we went through cons_fix_new_hppa, we classified them as complex.  */
1402   /* ??? It might be better to hide this +8 stuff in tc_cfi_emit_pcrel_expr,
1403      undefine DIFF_EXPR_OK, and let these sorts of complex expressions fail
1404      when R_HPPA_COMPLEX == R_PARISC_UNIMPLEMENTED.  */
1405   if (fixp->fx_r_type == (bfd_reloc_code_real_type) R_HPPA_COMPLEX
1406       && fixp->fx_pcrel)
1407     {
1408       fixp->fx_r_type = R_HPPA_PCREL_CALL;
1409       fixp->fx_offset += 8;
1410     }
1411
1412   codes = hppa_gen_reloc_type (stdoutput,
1413                                fixp->fx_r_type,
1414                                hppa_fixp->fx_r_format,
1415                                hppa_fixp->fx_r_field,
1416                                fixp->fx_subsy != NULL,
1417                                symbol_get_bfdsym (fixp->fx_addsy));
1418
1419   if (codes == NULL)
1420     {
1421       as_bad_where (fixp->fx_file, fixp->fx_line, _("Cannot handle fixup"));
1422       abort ();
1423     }
1424
1425   for (n_relocs = 0; codes[n_relocs]; n_relocs++)
1426     ;
1427
1428   relocs = xmalloc (sizeof (arelent *) * n_relocs + 1);
1429   reloc = xmalloc (sizeof (arelent) * n_relocs);
1430   for (i = 0; i < n_relocs; i++)
1431     relocs[i] = &reloc[i];
1432
1433   relocs[n_relocs] = NULL;
1434
1435 #ifdef OBJ_ELF
1436   switch (fixp->fx_r_type)
1437     {
1438     default:
1439       gas_assert (n_relocs == 1);
1440
1441       code = *codes[0];
1442
1443       /* Now, do any processing that is dependent on the relocation type.  */
1444       switch (code)
1445         {
1446         case R_PARISC_DLTREL21L:
1447         case R_PARISC_DLTREL14R:
1448         case R_PARISC_DLTREL14F:
1449         case R_PARISC_PLABEL32:
1450         case R_PARISC_PLABEL21L:
1451         case R_PARISC_PLABEL14R:
1452           /* For plabel relocations, the addend of the
1453              relocation should be either 0 (no static link) or 2
1454              (static link required).  This adjustment is done in
1455              bfd/elf32-hppa.c:elf32_hppa_relocate_section.
1456
1457              We also slam a zero addend into the DLT relative relocs;
1458              it doesn't make a lot of sense to use any addend since
1459              it gets you a different (eg unknown) DLT entry.  */
1460           reloc->addend = 0;
1461           break;
1462
1463 #ifdef ELF_ARG_RELOC
1464         case R_PARISC_PCREL17R:
1465         case R_PARISC_PCREL17F:
1466         case R_PARISC_PCREL17C:
1467         case R_PARISC_DIR17R:
1468         case R_PARISC_DIR17F:
1469         case R_PARISC_PCREL21L:
1470         case R_PARISC_DIR21L:
1471           reloc->addend = HPPA_R_ADDEND (hppa_fixp->fx_arg_reloc,
1472                                          fixp->fx_offset);
1473           break;
1474 #endif
1475
1476         case R_PARISC_DIR32:
1477           /* Facilitate hand-crafted unwind info.  */
1478           if (strcmp (section->name, UNWIND_SECTION_NAME) == 0)
1479             code = R_PARISC_SEGREL32;
1480           /* Fall thru */
1481
1482         default:
1483           reloc->addend = fixp->fx_offset;
1484           break;
1485         }
1486
1487       reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
1488       *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1489       reloc->howto = bfd_reloc_type_lookup (stdoutput,
1490                                             (bfd_reloc_code_real_type) code);
1491       reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
1492
1493       gas_assert (reloc->howto && (unsigned int) code == reloc->howto->type);
1494       break;
1495     }
1496 #else /* OBJ_SOM */
1497
1498   /* Walk over reach relocation returned by the BFD backend.  */
1499   for (i = 0; i < n_relocs; i++)
1500     {
1501       code = *codes[i];
1502
1503       relocs[i]->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
1504       *relocs[i]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1505       relocs[i]->howto =
1506         bfd_reloc_type_lookup (stdoutput,
1507                                (bfd_reloc_code_real_type) code);
1508       relocs[i]->address = fixp->fx_frag->fr_address + fixp->fx_where;
1509
1510       switch (code)
1511         {
1512         case R_COMP2:
1513           /* The only time we ever use a R_COMP2 fixup is for the difference
1514              of two symbols.  With that in mind we fill in all four
1515              relocs now and break out of the loop.  */
1516           gas_assert (i == 1);
1517           relocs[0]->sym_ptr_ptr
1518             = (asymbol **) bfd_abs_section_ptr->symbol_ptr_ptr;
1519           relocs[0]->howto
1520             = bfd_reloc_type_lookup (stdoutput,
1521                                      (bfd_reloc_code_real_type) *codes[0]);
1522           relocs[0]->address = fixp->fx_frag->fr_address + fixp->fx_where;
1523           relocs[0]->addend = 0;
1524           relocs[1]->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
1525           *relocs[1]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1526           relocs[1]->howto
1527             = bfd_reloc_type_lookup (stdoutput,
1528                                      (bfd_reloc_code_real_type) *codes[1]);
1529           relocs[1]->address = fixp->fx_frag->fr_address + fixp->fx_where;
1530           relocs[1]->addend = 0;
1531           relocs[2]->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
1532           *relocs[2]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_subsy);
1533           relocs[2]->howto
1534             = bfd_reloc_type_lookup (stdoutput,
1535                                      (bfd_reloc_code_real_type) *codes[2]);
1536           relocs[2]->address = fixp->fx_frag->fr_address + fixp->fx_where;
1537           relocs[2]->addend = 0;
1538           relocs[3]->sym_ptr_ptr
1539             = (asymbol **) bfd_abs_section_ptr->symbol_ptr_ptr;
1540           relocs[3]->howto
1541             = bfd_reloc_type_lookup (stdoutput,
1542                                      (bfd_reloc_code_real_type) *codes[3]);
1543           relocs[3]->address = fixp->fx_frag->fr_address + fixp->fx_where;
1544           relocs[3]->addend = 0;
1545           relocs[4]->sym_ptr_ptr
1546             = (asymbol **) bfd_abs_section_ptr->symbol_ptr_ptr;
1547           relocs[4]->howto
1548             = bfd_reloc_type_lookup (stdoutput,
1549                                      (bfd_reloc_code_real_type) *codes[4]);
1550           relocs[4]->address = fixp->fx_frag->fr_address + fixp->fx_where;
1551           relocs[4]->addend = 0;
1552           goto done;
1553         case R_PCREL_CALL:
1554         case R_ABS_CALL:
1555           relocs[i]->addend = HPPA_R_ADDEND (hppa_fixp->fx_arg_reloc, 0);
1556           break;
1557
1558         case R_DLT_REL:
1559         case R_DATA_PLABEL:
1560         case R_CODE_PLABEL:
1561           /* For plabel relocations, the addend of the
1562              relocation should be either 0 (no static link) or 2
1563              (static link required).
1564
1565              FIXME: We always assume no static link!
1566
1567              We also slam a zero addend into the DLT relative relocs;
1568              it doesn't make a lot of sense to use any addend since
1569              it gets you a different (eg unknown) DLT entry.  */
1570           relocs[i]->addend = 0;
1571           break;
1572
1573         case R_N_MODE:
1574         case R_S_MODE:
1575         case R_D_MODE:
1576         case R_R_MODE:
1577         case R_FSEL:
1578         case R_LSEL:
1579         case R_RSEL:
1580         case R_BEGIN_BRTAB:
1581         case R_END_BRTAB:
1582         case R_BEGIN_TRY:
1583         case R_N0SEL:
1584         case R_N1SEL:
1585           /* There is no symbol or addend associated with these fixups.  */
1586           relocs[i]->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
1587           *relocs[i]->sym_ptr_ptr = symbol_get_bfdsym (dummy_symbol);
1588           relocs[i]->addend = 0;
1589           break;
1590
1591         case R_END_TRY:
1592         case R_ENTRY:
1593         case R_EXIT:
1594           /* There is no symbol associated with these fixups.  */
1595           relocs[i]->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
1596           *relocs[i]->sym_ptr_ptr = symbol_get_bfdsym (dummy_symbol);
1597           relocs[i]->addend = fixp->fx_offset;
1598           break;
1599
1600         default:
1601           relocs[i]->addend = fixp->fx_offset;
1602         }
1603     }
1604
1605  done:
1606 #endif
1607
1608   return relocs;
1609 }
1610
1611 /* Process any machine dependent frag types.  */
1612
1613 void
1614 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
1615                  asection *sec ATTRIBUTE_UNUSED,
1616                  fragS *fragP)
1617 {
1618   unsigned int address;
1619
1620   if (fragP->fr_type == rs_machine_dependent)
1621     {
1622       switch ((int) fragP->fr_subtype)
1623         {
1624         case 0:
1625           fragP->fr_type = rs_fill;
1626           know (fragP->fr_var == 1);
1627           know (fragP->fr_next);
1628           address = fragP->fr_address + fragP->fr_fix;
1629           if (address % fragP->fr_offset)
1630             {
1631               fragP->fr_offset =
1632                 fragP->fr_next->fr_address
1633                 - fragP->fr_address
1634                 - fragP->fr_fix;
1635             }
1636           else
1637             fragP->fr_offset = 0;
1638           break;
1639         }
1640     }
1641 }
1642
1643 /* Round up a section size to the appropriate boundary.  */
1644
1645 valueT
1646 md_section_align (asection *segment, valueT size)
1647 {
1648   int align = bfd_get_section_alignment (stdoutput, segment);
1649   int align2 = (1 << align) - 1;
1650
1651   return (size + align2) & ~align2;
1652 }
1653
1654 /* Return the approximate size of a frag before relaxation has occurred.  */
1655
1656 int
1657 md_estimate_size_before_relax (fragS *fragP, asection *segment ATTRIBUTE_UNUSED)
1658 {
1659   int size;
1660
1661   size = 0;
1662
1663   while ((fragP->fr_fix + size) % fragP->fr_offset)
1664     size++;
1665
1666   return size;
1667 }
1668 \f
1669 #ifdef OBJ_ELF
1670 # ifdef WARN_COMMENTS
1671 const char *md_shortopts = "Vc";
1672 # else
1673 const char *md_shortopts = "V";
1674 # endif
1675 #else
1676 # ifdef WARN_COMMENTS
1677 const char *md_shortopts = "c";
1678 # else
1679 const char *md_shortopts = "";
1680 # endif
1681 #endif
1682
1683 struct option md_longopts[] =
1684 {
1685 #ifdef WARN_COMMENTS
1686   {"warn-comment", no_argument, NULL, 'c'},
1687 #endif
1688   {NULL, no_argument, NULL, 0}
1689 };
1690 size_t md_longopts_size = sizeof (md_longopts);
1691
1692 int
1693 md_parse_option (int c, char *arg ATTRIBUTE_UNUSED)
1694 {
1695   switch (c)
1696     {
1697     default:
1698       return 0;
1699
1700 #ifdef OBJ_ELF
1701     case 'V':
1702       print_version_id ();
1703       break;
1704 #endif
1705 #ifdef WARN_COMMENTS
1706     case 'c':
1707       warn_comment = 1;
1708       break;
1709 #endif
1710     }
1711
1712   return 1;
1713 }
1714
1715 void
1716 md_show_usage (FILE *stream ATTRIBUTE_UNUSED)
1717 {
1718 #ifdef OBJ_ELF
1719   fprintf (stream, _("\
1720   -Q                      ignored\n"));
1721 #endif
1722 #ifdef WARN_COMMENTS
1723   fprintf (stream, _("\
1724   -c                      print a warning if a comment is found\n"));
1725 #endif
1726 }
1727 \f
1728 /* We have no need to default values of symbols.  */
1729
1730 symbolS *
1731 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
1732 {
1733   return NULL;
1734 }
1735
1736 #if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
1737 #define nonzero_dibits(x) \
1738   ((x) | (((x) & 0x55555555) << 1) | (((x) & 0xAAAAAAAA) >> 1))
1739 #define arg_reloc_stub_needed(CALLER, CALLEE) \
1740   (((CALLER) ^ (CALLEE)) & nonzero_dibits (CALLER) & nonzero_dibits (CALLEE))
1741 #else
1742 #define arg_reloc_stub_needed(CALLER, CALLEE) 0
1743 #endif
1744
1745 /* Apply a fixup to an instruction.  */
1746
1747 void
1748 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
1749 {
1750   char *fixpos;
1751   struct hppa_fix_struct *hppa_fixP;
1752   offsetT new_val;
1753   int insn, val, fmt;
1754
1755   /* SOM uses R_HPPA_ENTRY and R_HPPA_EXIT relocations which can
1756      never be "applied" (they are just markers).  Likewise for
1757      R_HPPA_BEGIN_BRTAB and R_HPPA_END_BRTAB.  */
1758 #ifdef OBJ_SOM
1759   if (fixP->fx_r_type == R_HPPA_ENTRY
1760       || fixP->fx_r_type == R_HPPA_EXIT
1761       || fixP->fx_r_type == R_HPPA_BEGIN_BRTAB
1762       || fixP->fx_r_type == R_HPPA_END_BRTAB
1763       || fixP->fx_r_type == R_HPPA_BEGIN_TRY)
1764     return;
1765
1766   /* Disgusting.  We must set fx_offset ourselves -- R_HPPA_END_TRY
1767      fixups are considered not adjustable, which in turn causes
1768      adjust_reloc_syms to not set fx_offset.  Ugh.  */
1769   if (fixP->fx_r_type == R_HPPA_END_TRY)
1770     {
1771       fixP->fx_offset = * valP;
1772       return;
1773     }
1774 #endif
1775 #ifdef OBJ_ELF
1776   if (fixP->fx_r_type == (int) R_PARISC_GNU_VTENTRY
1777       || fixP->fx_r_type == (int) R_PARISC_GNU_VTINHERIT)
1778     return;
1779 #endif
1780
1781   if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
1782     fixP->fx_done = 1;
1783
1784   /* There should be a HPPA specific fixup associated with the GAS fixup.  */
1785   hppa_fixP = (struct hppa_fix_struct *) fixP->tc_fix_data;
1786   if (hppa_fixP == NULL)
1787     {
1788       as_bad_where (fixP->fx_file, fixP->fx_line,
1789                     _("no hppa_fixup entry for fixup type 0x%x"),
1790                     fixP->fx_r_type);
1791       return;
1792     }
1793
1794   fixpos = fixP->fx_frag->fr_literal + fixP->fx_where;
1795
1796   if (fixP->fx_size != 4 || hppa_fixP->fx_r_format == 32)
1797     {
1798       /* Handle constant output. */
1799       number_to_chars_bigendian (fixpos, *valP, fixP->fx_size);
1800       return;
1801     }
1802
1803   insn = bfd_get_32 (stdoutput, fixpos);
1804   fmt = bfd_hppa_insn2fmt (stdoutput, insn);
1805
1806   /* If there is a symbol associated with this fixup, then it's something
1807      which will need a SOM relocation (except for some PC-relative relocs).
1808      In such cases we should treat the "val" or "addend" as zero since it
1809      will be added in as needed from fx_offset in tc_gen_reloc.  */
1810   if ((fixP->fx_addsy != NULL
1811        || fixP->fx_r_type == (int) R_HPPA_NONE)
1812 #ifdef OBJ_SOM
1813       && fmt != 32
1814 #endif
1815       )
1816     new_val = ((fmt == 12 || fmt == 17 || fmt == 22) ? 8 : 0);
1817 #ifdef OBJ_SOM
1818   /* These field selectors imply that we do not want an addend.  */
1819   else if (hppa_fixP->fx_r_field == e_psel
1820            || hppa_fixP->fx_r_field == e_rpsel
1821            || hppa_fixP->fx_r_field == e_lpsel
1822            || hppa_fixP->fx_r_field == e_tsel
1823            || hppa_fixP->fx_r_field == e_rtsel
1824            || hppa_fixP->fx_r_field == e_ltsel)
1825     new_val = ((fmt == 12 || fmt == 17 || fmt == 22) ? 8 : 0);
1826 #endif
1827   else
1828     new_val = hppa_field_adjust (* valP, 0, hppa_fixP->fx_r_field);
1829
1830   /* Handle pc-relative exceptions from above.  */
1831   if ((fmt == 12 || fmt == 17 || fmt == 22)
1832       && fixP->fx_addsy
1833       && fixP->fx_pcrel
1834       && !arg_reloc_stub_needed (symbol_arg_reloc_info (fixP->fx_addsy),
1835                                  hppa_fixP->fx_arg_reloc)
1836 #ifdef OBJ_ELF
1837       && (* valP - 8 + 8192 < 16384
1838           || (fmt == 17 && * valP - 8 + 262144 < 524288)
1839           || (fmt == 22 && * valP - 8 + 8388608 < 16777216))
1840 #endif
1841 #ifdef OBJ_SOM
1842       && (* valP - 8 + 262144 < 524288
1843           || (fmt == 22 && * valP - 8 + 8388608 < 16777216))
1844 #endif
1845       && !S_IS_EXTERNAL (fixP->fx_addsy)
1846       && !S_IS_WEAK (fixP->fx_addsy)
1847       && S_GET_SEGMENT (fixP->fx_addsy) == hppa_fixP->segment
1848       && !(fixP->fx_subsy
1849            && S_GET_SEGMENT (fixP->fx_subsy) != hppa_fixP->segment))
1850     {
1851       new_val = hppa_field_adjust (* valP, 0, hppa_fixP->fx_r_field);
1852     }
1853
1854   switch (fmt)
1855     {
1856     case 10:
1857       CHECK_FIELD_WHERE (new_val, 8191, -8192,
1858                          fixP->fx_file, fixP->fx_line);
1859       val = new_val;
1860
1861       insn = (insn & ~ 0x3ff1) | (((val & 0x1ff8) << 1)
1862                                   | ((val & 0x2000) >> 13));
1863       break;
1864     case -11:
1865       CHECK_FIELD_WHERE (new_val, 8191, -8192,
1866                          fixP->fx_file, fixP->fx_line);
1867       val = new_val;
1868
1869       insn = (insn & ~ 0x3ff9) | (((val & 0x1ffc) << 1)
1870                                   | ((val & 0x2000) >> 13));
1871       break;
1872       /* Handle all opcodes with the 'j' operand type.  */
1873     case 14:
1874       CHECK_FIELD_WHERE (new_val, 8191, -8192,
1875                          fixP->fx_file, fixP->fx_line);
1876       val = new_val;
1877
1878       insn = ((insn & ~ 0x3fff) | low_sign_unext (val, 14));
1879       break;
1880
1881       /* Handle all opcodes with the 'k' operand type.  */
1882     case 21:
1883       CHECK_FIELD_WHERE (new_val, 1048575, -1048576,
1884                          fixP->fx_file, fixP->fx_line);
1885       val = new_val;
1886
1887       insn = (insn & ~ 0x1fffff) | re_assemble_21 (val);
1888       break;
1889
1890       /* Handle all the opcodes with the 'i' operand type.  */
1891     case 11:
1892       CHECK_FIELD_WHERE (new_val, 1023, -1024,
1893                          fixP->fx_file, fixP->fx_line);
1894       val = new_val;
1895
1896       insn = (insn & ~ 0x7ff) | low_sign_unext (val, 11);
1897       break;
1898
1899       /* Handle all the opcodes with the 'w' operand type.  */
1900     case 12:
1901       CHECK_FIELD_WHERE (new_val - 8, 8191, -8192,
1902                          fixP->fx_file, fixP->fx_line);
1903       val = new_val - 8;
1904
1905       insn = (insn & ~ 0x1ffd) | re_assemble_12 (val >> 2);
1906       break;
1907
1908       /* Handle some of the opcodes with the 'W' operand type.  */
1909     case 17:
1910       {
1911         offsetT distance = * valP;
1912
1913         /* If this is an absolute branch (ie no link) with an out of
1914            range target, then we want to complain.  */
1915         if (fixP->fx_r_type == (int) R_HPPA_PCREL_CALL
1916             && (insn & 0xffe00000) == 0xe8000000)
1917           CHECK_FIELD_WHERE (distance - 8, 262143, -262144,
1918                              fixP->fx_file, fixP->fx_line);
1919
1920         CHECK_FIELD_WHERE (new_val - 8, 262143, -262144,
1921                            fixP->fx_file, fixP->fx_line);
1922         val = new_val - 8;
1923
1924         insn = (insn & ~ 0x1f1ffd) | re_assemble_17 (val >> 2);
1925         break;
1926       }
1927
1928     case 22:
1929       {
1930         offsetT distance = * valP;
1931
1932         /* If this is an absolute branch (ie no link) with an out of
1933            range target, then we want to complain.  */
1934         if (fixP->fx_r_type == (int) R_HPPA_PCREL_CALL
1935             && (insn & 0xffe00000) == 0xe8000000)
1936           CHECK_FIELD_WHERE (distance - 8, 8388607, -8388608,
1937                              fixP->fx_file, fixP->fx_line);
1938
1939         CHECK_FIELD_WHERE (new_val - 8, 8388607, -8388608,
1940                            fixP->fx_file, fixP->fx_line);
1941         val = new_val - 8;
1942
1943         insn = (insn & ~ 0x3ff1ffd) | re_assemble_22 (val >> 2);
1944         break;
1945       }
1946
1947     case -10:
1948       val = new_val;
1949       insn = (insn & ~ 0xfff1) | re_assemble_16 (val & -8);
1950       break;
1951
1952     case -16:
1953       val = new_val;
1954       insn = (insn & ~ 0xfff9) | re_assemble_16 (val & -4);
1955       break;
1956
1957     case 16:
1958       val = new_val;
1959       insn = (insn & ~ 0xffff) | re_assemble_16 (val);
1960       break;
1961
1962     case 32:
1963       insn = new_val;
1964       break;
1965
1966     default:
1967       as_bad_where (fixP->fx_file, fixP->fx_line,
1968                     _("Unknown relocation encountered in md_apply_fix."));
1969       return;
1970     }
1971
1972 #ifdef OBJ_ELF
1973   switch (fixP->fx_r_type)
1974     {
1975       case R_PARISC_TLS_GD21L:
1976       case R_PARISC_TLS_GD14R:
1977       case R_PARISC_TLS_LDM21L:
1978       case R_PARISC_TLS_LDM14R:
1979       case R_PARISC_TLS_LE21L:
1980       case R_PARISC_TLS_LE14R:
1981       case R_PARISC_TLS_IE21L:
1982       case R_PARISC_TLS_IE14R:
1983         if (fixP->fx_addsy)
1984           S_SET_THREAD_LOCAL (fixP->fx_addsy);
1985         break;
1986       default:
1987         break;
1988     }
1989 #endif
1990
1991   /* Insert the relocation.  */
1992   bfd_put_32 (stdoutput, insn, fixpos);
1993 }
1994
1995 /* Exactly what point is a PC-relative offset relative TO?
1996    On the PA, they're relative to the address of the offset.  */
1997
1998 long
1999 md_pcrel_from (fixS *fixP)
2000 {
2001   return fixP->fx_where + fixP->fx_frag->fr_address;
2002 }
2003
2004 /* Return nonzero if the input line pointer is at the end of
2005    a statement.  */
2006
2007 static int
2008 is_end_of_statement (void)
2009 {
2010   return ((*input_line_pointer == '\n')
2011           || (*input_line_pointer == ';')
2012           || (*input_line_pointer == '!'));
2013 }
2014
2015 #define REG_NAME_CNT    (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
2016
2017 /* Given NAME, find the register number associated with that name, return
2018    the integer value associated with the given name or -1 on failure.  */
2019
2020 static int
2021 reg_name_search (char *name)
2022 {
2023   int middle, low, high;
2024   int cmp;
2025
2026   low = 0;
2027   high = REG_NAME_CNT - 1;
2028
2029   do
2030     {
2031       middle = (low + high) / 2;
2032       cmp = strcasecmp (name, pre_defined_registers[middle].name);
2033       if (cmp < 0)
2034         high = middle - 1;
2035       else if (cmp > 0)
2036         low = middle + 1;
2037       else
2038         return pre_defined_registers[middle].value;
2039     }
2040   while (low <= high);
2041
2042   return -1;
2043 }
2044
2045 /* Read a number from S.  The number might come in one of many forms,
2046    the most common will be a hex or decimal constant, but it could be
2047    a pre-defined register (Yuk!), or an absolute symbol.
2048
2049    Return 1 on success or 0 on failure.  If STRICT, then a missing
2050    register prefix will cause a failure.  The number itself is
2051    returned in `pa_number'.
2052
2053    IS_FLOAT indicates that a PA-89 FP register number should be
2054    parsed;  A `l' or `r' suffix is checked for if but 2 of IS_FLOAT is
2055    not set.
2056
2057    pa_parse_number can not handle negative constants and will fail
2058    horribly if it is passed such a constant.  */
2059
2060 static int
2061 pa_parse_number (char **s, int is_float)
2062 {
2063   int num;
2064   char *name;
2065   char c;
2066   symbolS *sym;
2067   int status;
2068   char *p = *s;
2069   bfd_boolean have_prefix;
2070
2071   /* Skip whitespace before the number.  */
2072   while (*p == ' ' || *p == '\t')
2073     p = p + 1;
2074
2075   pa_number = -1;
2076   have_prefix = 0;
2077   num = 0;
2078   if (!strict && ISDIGIT (*p))
2079     {
2080       /* Looks like a number.  */
2081
2082       if (*p == '0' && (*(p + 1) == 'x' || *(p + 1) == 'X'))
2083         {
2084           /* The number is specified in hex.  */
2085           p += 2;
2086           while (ISDIGIT (*p) || ((*p >= 'a') && (*p <= 'f'))
2087                  || ((*p >= 'A') && (*p <= 'F')))
2088             {
2089               if (ISDIGIT (*p))
2090                 num = num * 16 + *p - '0';
2091               else if (*p >= 'a' && *p <= 'f')
2092                 num = num * 16 + *p - 'a' + 10;
2093               else
2094                 num = num * 16 + *p - 'A' + 10;
2095               ++p;
2096             }
2097         }
2098       else
2099         {
2100           /* The number is specified in decimal.  */
2101           while (ISDIGIT (*p))
2102             {
2103               num = num * 10 + *p - '0';
2104               ++p;
2105             }
2106         }
2107
2108       pa_number = num;
2109
2110       /* Check for a `l' or `r' suffix.  */
2111       if (is_float)
2112         {
2113           pa_number += FP_REG_BASE;
2114           if (! (is_float & 2))
2115             {
2116               if (IS_R_SELECT (p))
2117                 {
2118                   pa_number += FP_REG_RSEL;
2119                   ++p;
2120                 }
2121               else if (IS_L_SELECT (p))
2122                 {
2123                   ++p;
2124                 }
2125             }
2126         }
2127     }
2128   else if (*p == '%')
2129     {
2130       /* The number might be a predefined register.  */
2131       have_prefix = 1;
2132       name = p;
2133       p++;
2134       c = *p;
2135       /* Tege hack: Special case for general registers as the general
2136          code makes a binary search with case translation, and is VERY
2137          slow.  */
2138       if (c == 'r')
2139         {
2140           p++;
2141           if (*p == 'e' && *(p + 1) == 't'
2142               && (*(p + 2) == '0' || *(p + 2) == '1'))
2143             {
2144               p += 2;
2145               num = *p - '0' + 28;
2146               p++;
2147             }
2148           else if (*p == 'p')
2149             {
2150               num = 2;
2151               p++;
2152             }
2153           else if (!ISDIGIT (*p))
2154             {
2155               if (print_errors)
2156                 as_bad (_("Undefined register: '%s'."), name);
2157               num = -1;
2158             }
2159           else
2160             {
2161               do
2162                 num = num * 10 + *p++ - '0';
2163               while (ISDIGIT (*p));
2164             }
2165         }
2166       else
2167         {
2168           /* Do a normal register search.  */
2169           while (is_part_of_name (c))
2170             {
2171               p = p + 1;
2172               c = *p;
2173             }
2174           *p = 0;
2175           status = reg_name_search (name);
2176           if (status >= 0)
2177             num = status;
2178           else
2179             {
2180               if (print_errors)
2181                 as_bad (_("Undefined register: '%s'."), name);
2182               num = -1;
2183             }
2184           *p = c;
2185         }
2186
2187       pa_number = num;
2188     }
2189   else
2190     {
2191       /* And finally, it could be a symbol in the absolute section which
2192          is effectively a constant, or a register alias symbol.  */
2193       name = p;
2194       c = *p;
2195       while (is_part_of_name (c))
2196         {
2197           p = p + 1;
2198           c = *p;
2199         }
2200       *p = 0;
2201       if ((sym = symbol_find (name)) != NULL)
2202         {
2203           if (S_GET_SEGMENT (sym) == reg_section)
2204             {
2205               num = S_GET_VALUE (sym);
2206               /* Well, we don't really have one, but we do have a
2207                  register, so...  */
2208               have_prefix = TRUE;
2209             }
2210           else if (S_GET_SEGMENT (sym) == &bfd_abs_section)
2211             num = S_GET_VALUE (sym);
2212           else if (!strict)
2213             {
2214               if (print_errors)
2215                 as_bad (_("Non-absolute symbol: '%s'."), name);
2216               num = -1;
2217             }
2218         }
2219       else if (!strict)
2220         {
2221           /* There is where we'd come for an undefined symbol
2222              or for an empty string.  For an empty string we
2223              will return zero.  That's a concession made for
2224              compatibility with the braindamaged HP assemblers.  */
2225           if (*name == 0)
2226             num = 0;
2227           else
2228             {
2229               if (print_errors)
2230                 as_bad (_("Undefined absolute constant: '%s'."), name);
2231               num = -1;
2232             }
2233         }
2234       *p = c;
2235
2236       pa_number = num;
2237     }
2238
2239   if (!strict || have_prefix)
2240     {
2241       *s = p;
2242       return 1;
2243     }
2244   return 0;
2245 }
2246
2247 /* Return nonzero if the given INSN and L/R information will require
2248    a new PA-1.1 opcode.  */
2249
2250 static int
2251 need_pa11_opcode (void)
2252 {
2253   if ((pa_number & FP_REG_RSEL) != 0
2254       && !(the_insn.fpof1 == DBL && the_insn.fpof2 == DBL))
2255     {
2256       /* If this instruction is specific to a particular architecture,
2257          then set a new architecture.  */
2258       if (bfd_get_mach (stdoutput) < pa11)
2259         {
2260           if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, pa11))
2261             as_warn (_("could not update architecture and machine"));
2262         }
2263       return TRUE;
2264     }
2265   else
2266     return FALSE;
2267 }
2268
2269 /* Parse a condition for a fcmp instruction.  Return the numerical
2270    code associated with the condition.  */
2271
2272 static int
2273 pa_parse_fp_cmp_cond (char **s)
2274 {
2275   int cond, i;
2276
2277   cond = 0;
2278
2279   for (i = 0; i < 32; i++)
2280     {
2281       if (strncasecmp (*s, fp_cond_map[i].string,
2282                        strlen (fp_cond_map[i].string)) == 0)
2283         {
2284           cond = fp_cond_map[i].cond;
2285           *s += strlen (fp_cond_map[i].string);
2286           /* If not a complete match, back up the input string and
2287              report an error.  */
2288           if (**s != ' ' && **s != '\t')
2289             {
2290               *s -= strlen (fp_cond_map[i].string);
2291               break;
2292             }
2293           while (**s == ' ' || **s == '\t')
2294             *s = *s + 1;
2295           return cond;
2296         }
2297     }
2298
2299   as_bad (_("Invalid FP Compare Condition: %s"), *s);
2300
2301   /* Advance over the bogus completer.  */
2302   while (**s != ',' && **s != ' ' && **s != '\t')
2303     *s += 1;
2304
2305   return 0;
2306 }
2307
2308 /* Parse a graphics test complete for ftest.  */
2309
2310 static int
2311 pa_parse_ftest_gfx_completer (char **s)
2312 {
2313   int value;
2314
2315   value = 0;
2316   if (strncasecmp (*s, "acc8", 4) == 0)
2317     {
2318       value = 5;
2319       *s += 4;
2320     }
2321   else if (strncasecmp (*s, "acc6", 4) == 0)
2322     {
2323       value = 9;
2324       *s += 4;
2325     }
2326   else if (strncasecmp (*s, "acc4", 4) == 0)
2327     {
2328       value = 13;
2329       *s += 4;
2330     }
2331   else if (strncasecmp (*s, "acc2", 4) == 0)
2332     {
2333       value = 17;
2334       *s += 4;
2335     }
2336   else if (strncasecmp (*s, "acc", 3) == 0)
2337     {
2338       value = 1;
2339       *s += 3;
2340     }
2341   else if (strncasecmp (*s, "rej8", 4) == 0)
2342     {
2343       value = 6;
2344       *s += 4;
2345     }
2346   else if (strncasecmp (*s, "rej", 3) == 0)
2347     {
2348       value = 2;
2349       *s += 3;
2350     }
2351   else
2352     {
2353       value = 0;
2354       as_bad (_("Invalid FTEST completer: %s"), *s);
2355     }
2356
2357   return value;
2358 }
2359
2360 /* Parse an FP operand format completer returning the completer
2361    type.  */
2362
2363 static fp_operand_format
2364 pa_parse_fp_cnv_format (char **s)
2365 {
2366   int format;
2367
2368   format = SGL;
2369   if (**s == ',')
2370     {
2371       *s += 1;
2372       if (strncasecmp (*s, "sgl", 3) == 0)
2373         {
2374           format = SGL;
2375           *s += 4;
2376         }
2377       else if (strncasecmp (*s, "dbl", 3) == 0)
2378         {
2379           format = DBL;
2380           *s += 4;
2381         }
2382       else if (strncasecmp (*s, "quad", 4) == 0)
2383         {
2384           format = QUAD;
2385           *s += 5;
2386         }
2387       else if (strncasecmp (*s, "w", 1) == 0)
2388         {
2389           format = W;
2390           *s += 2;
2391         }
2392       else if (strncasecmp (*s, "uw", 2) == 0)
2393         {
2394           format = UW;
2395           *s += 3;
2396         }
2397       else if (strncasecmp (*s, "dw", 2) == 0)
2398         {
2399           format = DW;
2400           *s += 3;
2401         }
2402       else if (strncasecmp (*s, "udw", 3) == 0)
2403         {
2404           format = UDW;
2405           *s += 4;
2406         }
2407       else if (strncasecmp (*s, "qw", 2) == 0)
2408         {
2409           format = QW;
2410           *s += 3;
2411         }
2412       else if (strncasecmp (*s, "uqw", 3) == 0)
2413         {
2414           format = UQW;
2415           *s += 4;
2416         }
2417       else
2418         {
2419           format = ILLEGAL_FMT;
2420           as_bad (_("Invalid FP Operand Format: %3s"), *s);
2421         }
2422     }
2423
2424   return format;
2425 }
2426
2427 /* Parse an FP operand format completer returning the completer
2428    type.  */
2429
2430 static fp_operand_format
2431 pa_parse_fp_format (char **s)
2432 {
2433   int format;
2434
2435   format = SGL;
2436   if (**s == ',')
2437     {
2438       *s += 1;
2439       if (strncasecmp (*s, "sgl", 3) == 0)
2440         {
2441           format = SGL;
2442           *s += 4;
2443         }
2444       else if (strncasecmp (*s, "dbl", 3) == 0)
2445         {
2446           format = DBL;
2447           *s += 4;
2448         }
2449       else if (strncasecmp (*s, "quad", 4) == 0)
2450         {
2451           format = QUAD;
2452           *s += 5;
2453         }
2454       else
2455         {
2456           format = ILLEGAL_FMT;
2457           as_bad (_("Invalid FP Operand Format: %3s"), *s);
2458         }
2459     }
2460
2461   return format;
2462 }
2463
2464 /* Convert from a selector string into a selector type.  */
2465
2466 static int
2467 pa_chk_field_selector (char **str)
2468 {
2469   int middle, low, high;
2470   int cmp;
2471   char name[4];
2472
2473   /* Read past any whitespace.  */
2474   /* FIXME: should we read past newlines and formfeeds??? */
2475   while (**str == ' ' || **str == '\t' || **str == '\n' || **str == '\f')
2476     *str = *str + 1;
2477
2478   if ((*str)[1] == '\'' || (*str)[1] == '%')
2479     name[0] = TOLOWER ((*str)[0]),
2480     name[1] = 0;
2481   else if ((*str)[2] == '\'' || (*str)[2] == '%')
2482     name[0] = TOLOWER ((*str)[0]),
2483     name[1] = TOLOWER ((*str)[1]),
2484     name[2] = 0;
2485   else if ((*str)[3] == '\'' || (*str)[3] == '%')
2486     name[0] = TOLOWER ((*str)[0]),
2487     name[1] = TOLOWER ((*str)[1]),
2488     name[2] = TOLOWER ((*str)[2]),
2489     name[3] = 0;
2490   else
2491     return e_fsel;
2492
2493   low = 0;
2494   high = sizeof (selector_table) / sizeof (struct selector_entry) - 1;
2495
2496   do
2497     {
2498       middle = (low + high) / 2;
2499       cmp = strcmp (name, selector_table[middle].prefix);
2500       if (cmp < 0)
2501         high = middle - 1;
2502       else if (cmp > 0)
2503         low = middle + 1;
2504       else
2505         {
2506           *str += strlen (name) + 1;
2507 #ifndef OBJ_SOM
2508           if (selector_table[middle].field_selector == e_nsel)
2509             return e_fsel;
2510 #endif
2511           return selector_table[middle].field_selector;
2512         }
2513     }
2514   while (low <= high);
2515
2516   return e_fsel;
2517 }
2518
2519 /* Parse a .byte, .word, .long expression for the HPPA.  Called by
2520    cons via the TC_PARSE_CONS_EXPRESSION macro.  */
2521
2522 void
2523 parse_cons_expression_hppa (expressionS *exp)
2524 {
2525   hppa_field_selector = pa_chk_field_selector (&input_line_pointer);
2526   expression (exp);
2527 }
2528
2529 /* Evaluate an absolute expression EXP which may be modified by
2530    the selector FIELD_SELECTOR.  Return the value of the expression.  */
2531 static int
2532 evaluate_absolute (struct pa_it *insn)
2533 {
2534   offsetT value;
2535   expressionS exp;
2536   int field_selector = insn->field_selector;
2537
2538   exp = insn->exp;
2539   value = exp.X_add_number;
2540
2541   return hppa_field_adjust (0, value, field_selector);
2542 }
2543
2544 /* Mark (via expr_end) the end of an absolute expression.  FIXME.  */
2545
2546 static int
2547 pa_get_absolute_expression (struct pa_it *insn, char **strp)
2548 {
2549   char *save_in;
2550
2551   insn->field_selector = pa_chk_field_selector (strp);
2552   save_in = input_line_pointer;
2553   input_line_pointer = *strp;
2554   expression (&insn->exp);
2555   /* This is not perfect, but is a huge improvement over doing nothing.
2556
2557      The PA assembly syntax is ambiguous in a variety of ways.  Consider
2558      this string "4 %r5"  Is that the number 4 followed by the register
2559      r5, or is that 4 MOD r5?
2560
2561      If we get a modulo expression when looking for an absolute, we try
2562      again cutting off the input string at the first whitespace character.  */
2563   if (insn->exp.X_op == O_modulus)
2564     {
2565       char *s, c;
2566
2567       input_line_pointer = *strp;
2568       s = *strp;
2569       while (*s != ',' && *s != ' ' && *s != '\t')
2570         s++;
2571
2572       c = *s;
2573       *s = 0;
2574
2575       pa_get_absolute_expression (insn, strp);
2576
2577       input_line_pointer = save_in;
2578       *s = c;
2579       return evaluate_absolute (insn);
2580     }
2581   /* When in strict mode we have a non-match, fix up the pointers
2582      and return to our caller.  */
2583   if (insn->exp.X_op != O_constant && strict)
2584     {
2585       expr_end = input_line_pointer;
2586       input_line_pointer = save_in;
2587       return 0;
2588     }
2589   if (insn->exp.X_op != O_constant)
2590     {
2591       as_bad (_("Bad segment (should be absolute)."));
2592       expr_end = input_line_pointer;
2593       input_line_pointer = save_in;
2594       return 0;
2595     }
2596   expr_end = input_line_pointer;
2597   input_line_pointer = save_in;
2598   return evaluate_absolute (insn);
2599 }
2600
2601 /* Given an argument location specification return the associated
2602    argument location number.  */
2603
2604 static unsigned int
2605 pa_build_arg_reloc (char *type_name)
2606 {
2607
2608   if (strncasecmp (type_name, "no", 2) == 0)
2609     return 0;
2610   if (strncasecmp (type_name, "gr", 2) == 0)
2611     return 1;
2612   else if (strncasecmp (type_name, "fr", 2) == 0)
2613     return 2;
2614   else if (strncasecmp (type_name, "fu", 2) == 0)
2615     return 3;
2616   else
2617     as_bad (_("Invalid argument location: %s\n"), type_name);
2618
2619   return 0;
2620 }
2621
2622 /* Encode and return an argument relocation specification for
2623    the given register in the location specified by arg_reloc.  */
2624
2625 static unsigned int
2626 pa_align_arg_reloc (unsigned int reg, unsigned int arg_reloc)
2627 {
2628   unsigned int new_reloc;
2629
2630   new_reloc = arg_reloc;
2631   switch (reg)
2632     {
2633     case 0:
2634       new_reloc <<= 8;
2635       break;
2636     case 1:
2637       new_reloc <<= 6;
2638       break;
2639     case 2:
2640       new_reloc <<= 4;
2641       break;
2642     case 3:
2643       new_reloc <<= 2;
2644       break;
2645     default:
2646       as_bad (_("Invalid argument description: %d"), reg);
2647     }
2648
2649   return new_reloc;
2650 }
2651
2652 /* Parse a non-negated compare/subtract completer returning the
2653    number (for encoding in instructions) of the given completer.  */
2654
2655 static int
2656 pa_parse_nonneg_cmpsub_cmpltr (char **s)
2657 {
2658   int cmpltr;
2659   char *name = *s + 1;
2660   char c;
2661   char *save_s = *s;
2662   int nullify = 0;
2663
2664   cmpltr = 0;
2665   if (**s == ',')
2666     {
2667       *s += 1;
2668       while (**s != ',' && **s != ' ' && **s != '\t')
2669         *s += 1;
2670       c = **s;
2671       **s = 0x00;
2672
2673       if (strcmp (name, "=") == 0)
2674         {
2675           cmpltr = 1;
2676         }
2677       else if (strcmp (name, "<") == 0)
2678         {
2679           cmpltr = 2;
2680         }
2681       else if (strcmp (name, "<=") == 0)
2682         {
2683           cmpltr = 3;
2684         }
2685       else if (strcmp (name, "<<") == 0)
2686         {
2687           cmpltr = 4;
2688         }
2689       else if (strcmp (name, "<<=") == 0)
2690         {
2691           cmpltr = 5;
2692         }
2693       else if (strcasecmp (name, "sv") == 0)
2694         {
2695           cmpltr = 6;
2696         }
2697       else if (strcasecmp (name, "od") == 0)
2698         {
2699           cmpltr = 7;
2700         }
2701       /* If we have something like addb,n then there is no condition
2702          completer.  */
2703       else if (strcasecmp (name, "n") == 0)
2704         {
2705           cmpltr = 0;
2706           nullify = 1;
2707         }
2708       else
2709         {
2710           cmpltr = -1;
2711         }
2712       **s = c;
2713     }
2714
2715   /* Reset pointers if this was really a ,n for a branch instruction.  */
2716   if (nullify)
2717     *s = save_s;
2718
2719   return cmpltr;
2720 }
2721
2722 /* Parse a negated compare/subtract completer returning the
2723    number (for encoding in instructions) of the given completer.  */
2724
2725 static int
2726 pa_parse_neg_cmpsub_cmpltr (char **s)
2727 {
2728   int cmpltr;
2729   char *name = *s + 1;
2730   char c;
2731   char *save_s = *s;
2732   int nullify = 0;
2733
2734   cmpltr = 0;
2735   if (**s == ',')
2736     {
2737       *s += 1;
2738       while (**s != ',' && **s != ' ' && **s != '\t')
2739         *s += 1;
2740       c = **s;
2741       **s = 0x00;
2742
2743       if (strcasecmp (name, "tr") == 0)
2744         {
2745           cmpltr = 0;
2746         }
2747       else if (strcmp (name, "<>") == 0)
2748         {
2749           cmpltr = 1;
2750         }
2751       else if (strcmp (name, ">=") == 0)
2752         {
2753           cmpltr = 2;
2754         }
2755       else if (strcmp (name, ">") == 0)
2756         {
2757           cmpltr = 3;
2758         }
2759       else if (strcmp (name, ">>=") == 0)
2760         {
2761           cmpltr = 4;
2762         }
2763       else if (strcmp (name, ">>") == 0)
2764         {
2765           cmpltr = 5;
2766         }
2767       else if (strcasecmp (name, "nsv") == 0)
2768         {
2769           cmpltr = 6;
2770         }
2771       else if (strcasecmp (name, "ev") == 0)
2772         {
2773           cmpltr = 7;
2774         }
2775       /* If we have something like addb,n then there is no condition
2776          completer.  */
2777       else if (strcasecmp (name, "n") == 0)
2778         {
2779           cmpltr = 0;
2780           nullify = 1;
2781         }
2782       else
2783         {
2784           cmpltr = -1;
2785         }
2786       **s = c;
2787     }
2788
2789   /* Reset pointers if this was really a ,n for a branch instruction.  */
2790   if (nullify)
2791     *s = save_s;
2792
2793   return cmpltr;
2794 }
2795
2796 /* Parse a 64 bit compare and branch completer returning the number (for
2797    encoding in instructions) of the given completer.
2798
2799    Nonnegated comparisons are returned as 0-7, negated comparisons are
2800    returned as 8-15.  */
2801
2802 static int
2803 pa_parse_cmpb_64_cmpltr (char **s)
2804 {
2805   int cmpltr;
2806   char *name = *s + 1;
2807   char c;
2808
2809   cmpltr = -1;
2810   if (**s == ',')
2811     {
2812       *s += 1;
2813       while (**s != ',' && **s != ' ' && **s != '\t')
2814         *s += 1;
2815       c = **s;
2816       **s = 0x00;
2817
2818       if (strcmp (name, "*") == 0)
2819         {
2820           cmpltr = 0;
2821         }
2822       else if (strcmp (name, "*=") == 0)
2823         {
2824           cmpltr = 1;
2825         }
2826       else if (strcmp (name, "*<") == 0)
2827         {
2828           cmpltr = 2;
2829         }
2830       else if (strcmp (name, "*<=") == 0)
2831         {
2832           cmpltr = 3;
2833         }
2834       else if (strcmp (name, "*<<") == 0)
2835         {
2836           cmpltr = 4;
2837         }
2838       else if (strcmp (name, "*<<=") == 0)
2839         {
2840           cmpltr = 5;
2841         }
2842       else if (strcasecmp (name, "*sv") == 0)
2843         {
2844           cmpltr = 6;
2845         }
2846       else if (strcasecmp (name, "*od") == 0)
2847         {
2848           cmpltr = 7;
2849         }
2850       else if (strcasecmp (name, "*tr") == 0)
2851         {
2852           cmpltr = 8;
2853         }
2854       else if (strcmp (name, "*<>") == 0)
2855         {
2856           cmpltr = 9;
2857         }
2858       else if (strcmp (name, "*>=") == 0)
2859         {
2860           cmpltr = 10;
2861         }
2862       else if (strcmp (name, "*>") == 0)
2863         {
2864           cmpltr = 11;
2865         }
2866       else if (strcmp (name, "*>>=") == 0)
2867         {
2868           cmpltr = 12;
2869         }
2870       else if (strcmp (name, "*>>") == 0)
2871         {
2872           cmpltr = 13;
2873         }
2874       else if (strcasecmp (name, "*nsv") == 0)
2875         {
2876           cmpltr = 14;
2877         }
2878       else if (strcasecmp (name, "*ev") == 0)
2879         {
2880           cmpltr = 15;
2881         }
2882       else
2883         {
2884           cmpltr = -1;
2885         }
2886       **s = c;
2887     }
2888
2889   return cmpltr;
2890 }
2891
2892 /* Parse a 64 bit compare immediate and branch completer returning the number
2893    (for encoding in instructions) of the given completer.  */
2894
2895 static int
2896 pa_parse_cmpib_64_cmpltr (char **s)
2897 {
2898   int cmpltr;
2899   char *name = *s + 1;
2900   char c;
2901
2902   cmpltr = -1;
2903   if (**s == ',')
2904     {
2905       *s += 1;
2906       while (**s != ',' && **s != ' ' && **s != '\t')
2907         *s += 1;
2908       c = **s;
2909       **s = 0x00;
2910
2911       if (strcmp (name, "*<<") == 0)
2912         {
2913           cmpltr = 0;
2914         }
2915       else if (strcmp (name, "*=") == 0)
2916         {
2917           cmpltr = 1;
2918         }
2919       else if (strcmp (name, "*<") == 0)
2920         {
2921           cmpltr = 2;
2922         }
2923       else if (strcmp (name, "*<=") == 0)
2924         {
2925           cmpltr = 3;
2926         }
2927       else if (strcmp (name, "*>>=") == 0)
2928         {
2929           cmpltr = 4;
2930         }
2931       else if (strcmp (name, "*<>") == 0)
2932         {
2933           cmpltr = 5;
2934         }
2935       else if (strcasecmp (name, "*>=") == 0)
2936         {
2937           cmpltr = 6;
2938         }
2939       else if (strcasecmp (name, "*>") == 0)
2940         {
2941           cmpltr = 7;
2942         }
2943       else
2944         {
2945           cmpltr = -1;
2946         }
2947       **s = c;
2948     }
2949
2950   return cmpltr;
2951 }
2952
2953 /* Parse a non-negated addition completer returning the number
2954    (for encoding in instructions) of the given completer.  */
2955
2956 static int
2957 pa_parse_nonneg_add_cmpltr (char **s)
2958 {
2959   int cmpltr;
2960   char *name = *s + 1;
2961   char c;
2962   char *save_s = *s;
2963   int nullify = 0;
2964
2965   cmpltr = 0;
2966   if (**s == ',')
2967     {
2968       *s += 1;
2969       while (**s != ',' && **s != ' ' && **s != '\t')
2970         *s += 1;
2971       c = **s;
2972       **s = 0x00;
2973       if (strcmp (name, "=") == 0)
2974         {
2975           cmpltr = 1;
2976         }
2977       else if (strcmp (name, "<") == 0)
2978         {
2979           cmpltr = 2;
2980         }
2981       else if (strcmp (name, "<=") == 0)
2982         {
2983           cmpltr = 3;
2984         }
2985       else if (strcasecmp (name, "nuv") == 0)
2986         {
2987           cmpltr = 4;
2988         }
2989       else if (strcasecmp (name, "znv") == 0)
2990         {
2991           cmpltr = 5;
2992         }
2993       else if (strcasecmp (name, "sv") == 0)
2994         {
2995           cmpltr = 6;
2996         }
2997       else if (strcasecmp (name, "od") == 0)
2998         {
2999           cmpltr = 7;
3000         }
3001       /* If we have something like addb,n then there is no condition
3002          completer.  */
3003       else if (strcasecmp (name, "n") == 0)
3004         {
3005           cmpltr = 0;
3006           nullify = 1;
3007         }
3008       else
3009         {
3010           cmpltr = -1;
3011         }
3012       **s = c;
3013     }
3014
3015   /* Reset pointers if this was really a ,n for a branch instruction.  */
3016   if (nullify)
3017     *s = save_s;
3018
3019   return cmpltr;
3020 }
3021
3022 /* Parse a negated addition completer returning the number
3023    (for encoding in instructions) of the given completer.  */
3024
3025 static int
3026 pa_parse_neg_add_cmpltr (char **s)
3027 {
3028   int cmpltr;
3029   char *name = *s + 1;
3030   char c;
3031   char *save_s = *s;
3032   int nullify = 0;
3033
3034   cmpltr = 0;
3035   if (**s == ',')
3036     {
3037       *s += 1;
3038       while (**s != ',' && **s != ' ' && **s != '\t')
3039         *s += 1;
3040       c = **s;
3041       **s = 0x00;
3042       if (strcasecmp (name, "tr") == 0)
3043         {
3044           cmpltr = 0;
3045         }
3046       else if (strcmp (name, "<>") == 0)
3047         {
3048           cmpltr = 1;
3049         }
3050       else if (strcmp (name, ">=") == 0)
3051         {
3052           cmpltr = 2;
3053         }
3054       else if (strcmp (name, ">") == 0)
3055         {
3056           cmpltr = 3;
3057         }
3058       else if (strcasecmp (name, "uv") == 0)
3059         {
3060           cmpltr = 4;
3061         }
3062       else if (strcasecmp (name, "vnz") == 0)
3063         {
3064           cmpltr = 5;
3065         }
3066       else if (strcasecmp (name, "nsv") == 0)
3067         {
3068           cmpltr = 6;
3069         }
3070       else if (strcasecmp (name, "ev") == 0)
3071         {
3072           cmpltr = 7;
3073         }
3074       /* If we have something like addb,n then there is no condition
3075          completer.  */
3076       else if (strcasecmp (name, "n") == 0)
3077         {
3078           cmpltr = 0;
3079           nullify = 1;
3080         }
3081       else
3082         {
3083           cmpltr = -1;
3084         }
3085       **s = c;
3086     }
3087
3088   /* Reset pointers if this was really a ,n for a branch instruction.  */
3089   if (nullify)
3090     *s = save_s;
3091
3092   return cmpltr;
3093 }
3094
3095 /* Parse a 64 bit wide mode add and branch completer returning the number (for
3096    encoding in instructions) of the given completer.  */
3097
3098 static int
3099 pa_parse_addb_64_cmpltr (char **s)
3100 {
3101   int cmpltr;
3102   char *name = *s + 1;
3103   char c;
3104   char *save_s = *s;
3105   int nullify = 0;
3106
3107   cmpltr = 0;
3108   if (**s == ',')
3109     {
3110       *s += 1;
3111       while (**s != ',' && **s != ' ' && **s != '\t')
3112         *s += 1;
3113       c = **s;
3114       **s = 0x00;
3115       if (strcmp (name, "=") == 0)
3116         {
3117           cmpltr = 1;
3118         }
3119       else if (strcmp (name, "<") == 0)
3120         {
3121           cmpltr = 2;
3122         }
3123       else if (strcmp (name, "<=") == 0)
3124         {
3125           cmpltr = 3;
3126         }
3127       else if (strcasecmp (name, "nuv") == 0)
3128         {
3129           cmpltr = 4;
3130         }
3131       else if (strcasecmp (name, "*=") == 0)
3132         {
3133           cmpltr = 5;
3134         }
3135       else if (strcasecmp (name, "*<") == 0)
3136         {
3137           cmpltr = 6;
3138         }
3139       else if (strcasecmp (name, "*<=") == 0)
3140         {
3141           cmpltr = 7;
3142         }
3143       else if (strcmp (name, "tr") == 0)
3144         {
3145           cmpltr = 8;
3146         }
3147       else if (strcmp (name, "<>") == 0)
3148         {
3149           cmpltr = 9;
3150         }
3151       else if (strcmp (name, ">=") == 0)
3152         {
3153           cmpltr = 10;
3154         }
3155       else if (strcmp (name, ">") == 0)
3156         {
3157           cmpltr = 11;
3158         }
3159       else if (strcasecmp (name, "uv") == 0)
3160         {
3161           cmpltr = 12;
3162         }
3163       else if (strcasecmp (name, "*<>") == 0)
3164         {
3165           cmpltr = 13;
3166         }
3167       else if (strcasecmp (name, "*>=") == 0)
3168         {
3169           cmpltr = 14;
3170         }
3171       else if (strcasecmp (name, "*>") == 0)
3172         {
3173           cmpltr = 15;
3174         }
3175       /* If we have something like addb,n then there is no condition
3176          completer.  */
3177       else if (strcasecmp (name, "n") == 0)
3178         {
3179           cmpltr = 0;
3180           nullify = 1;
3181         }
3182       else
3183         {
3184           cmpltr = -1;
3185         }
3186       **s = c;
3187     }
3188
3189   /* Reset pointers if this was really a ,n for a branch instruction.  */
3190   if (nullify)
3191     *s = save_s;
3192
3193   return cmpltr;
3194 }
3195
3196 /* Do the real work for assembling a single instruction.  Store results
3197    into the global "the_insn" variable.  */
3198
3199 static void
3200 pa_ip (char *str)
3201 {
3202   char *error_message = "";
3203   char *s, c, *argstart, *name, *save_s;
3204   const char *args;
3205   int match = FALSE;
3206   int comma = 0;
3207   int cmpltr, nullif, flag, cond, need_cond, num;
3208   int immediate_check = 0, pos = -1, len = -1;
3209   unsigned long opcode;
3210   struct pa_opcode *insn;
3211
3212 #ifdef OBJ_SOM
3213   /* We must have a valid space and subspace.  */
3214   pa_check_current_space_and_subspace ();
3215 #endif
3216
3217   /* Convert everything up to the first whitespace character into lower
3218      case.  */
3219   for (s = str; *s != ' ' && *s != '\t' && *s != '\n' && *s != '\0'; s++)
3220     *s = TOLOWER (*s);
3221
3222   /* Skip to something interesting.  */
3223   for (s = str;
3224        ISUPPER (*s) || ISLOWER (*s) || (*s >= '0' && *s <= '3');
3225        ++s)
3226     ;
3227
3228   switch (*s)
3229     {
3230
3231     case '\0':
3232       break;
3233
3234     case ',':
3235       comma = 1;
3236
3237       /*FALLTHROUGH */
3238
3239     case ' ':
3240       *s++ = '\0';
3241       break;
3242
3243     default:
3244       as_bad (_("Unknown opcode: `%s'"), str);
3245       return;
3246     }
3247
3248   /* Look up the opcode in the hash table.  */
3249   if ((insn = (struct pa_opcode *) hash_find (op_hash, str)) == NULL)
3250     {
3251       as_bad (_("Unknown opcode: `%s'"), str);
3252       return;
3253     }
3254
3255   if (comma)
3256     *--s = ',';
3257
3258   /* Mark the location where arguments for the instruction start, then
3259      start processing them.  */
3260   argstart = s;
3261   for (;;)
3262     {
3263       /* Do some initialization.  */
3264       opcode = insn->match;
3265       strict = (insn->flags & FLAG_STRICT);
3266       memset (&the_insn, 0, sizeof (the_insn));
3267       need_cond = 1;
3268
3269       the_insn.reloc = R_HPPA_NONE;
3270
3271       if (insn->arch >= pa20
3272           && bfd_get_mach (stdoutput) < insn->arch)
3273         goto failed;
3274
3275       /* Build the opcode, checking as we go to make
3276          sure that the operands match.  */
3277       for (args = insn->args;; ++args)
3278         {
3279           /* Absorb white space in instruction.  */
3280           while (*s == ' ' || *s == '\t')
3281             s++;
3282
3283           switch (*args)
3284             {
3285             /* End of arguments.  */
3286             case '\0':
3287               if (*s == '\0')
3288                 match = TRUE;
3289               break;
3290
3291             case '+':
3292               if (*s == '+')
3293                 {
3294                   ++s;
3295                   continue;
3296                 }
3297               if (*s == '-')
3298                 continue;
3299               break;
3300
3301             /* These must match exactly.  */
3302             case '(':
3303             case ')':
3304             case ',':
3305             case ' ':
3306               if (*s++ == *args)
3307                 continue;
3308               break;
3309
3310             /* Handle a 5 bit register or control register field at 10.  */
3311             case 'b':
3312             case '^':
3313               if (!pa_parse_number (&s, 0))
3314                 break;
3315               num = pa_number;
3316               CHECK_FIELD (num, 31, 0, 0);
3317               INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
3318
3319             /* Handle %sar or %cr11.  No bits get set, we just verify that it
3320                is there.  */
3321             case '!':
3322               /* Skip whitespace before register.  */
3323               while (*s == ' ' || *s == '\t')
3324                 s = s + 1;
3325
3326               if (!strncasecmp (s, "%sar", 4))
3327                 {
3328                   s += 4;
3329                   continue;
3330                 }
3331               else if (!strncasecmp (s, "%cr11", 5))
3332                 {
3333                   s += 5;
3334                   continue;
3335                 }
3336               break;
3337
3338             /* Handle a 5 bit register field at 15.  */
3339             case 'x':
3340               if (!pa_parse_number (&s, 0))
3341                 break;
3342               num = pa_number;
3343               CHECK_FIELD (num, 31, 0, 0);
3344               INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
3345
3346             /* Handle a 5 bit register field at 31.  */
3347             case 't':
3348               if (!pa_parse_number (&s, 0))
3349                 break;
3350               num = pa_number;
3351               CHECK_FIELD (num, 31, 0, 0);
3352               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3353
3354             /* Handle a 5 bit register field at 10 and 15.  */
3355             case 'a':
3356               if (!pa_parse_number (&s, 0))
3357                 break;
3358               num = pa_number;
3359               CHECK_FIELD (num, 31, 0, 0);
3360               opcode |= num << 16;
3361               INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
3362
3363             /* Handle a 5 bit field length at 31.  */
3364             case 'T':
3365               num = pa_get_absolute_expression (&the_insn, &s);
3366               if (strict && the_insn.exp.X_op != O_constant)
3367                 break;
3368               s = expr_end;
3369               CHECK_FIELD (num, 32, 1, 0);
3370               SAVE_IMMEDIATE(num);
3371               INSERT_FIELD_AND_CONTINUE (opcode, 32 - num, 0);
3372
3373             /* Handle a 5 bit immediate at 15.  */
3374             case '5':
3375               num = pa_get_absolute_expression (&the_insn, &s);
3376               if (strict && the_insn.exp.X_op != O_constant)
3377                 break;
3378               s = expr_end;
3379               /* When in strict mode, we want to just reject this
3380                  match instead of giving an out of range error.  */
3381               CHECK_FIELD (num, 15, -16, strict);
3382               num = low_sign_unext (num, 5);
3383               INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
3384
3385             /* Handle a 5 bit immediate at 31.  */
3386             case 'V':
3387               num = pa_get_absolute_expression (&the_insn, &s);
3388               if (strict && the_insn.exp.X_op != O_constant)
3389                 break;
3390               s = expr_end;
3391               /* When in strict mode, we want to just reject this
3392                  match instead of giving an out of range error.  */
3393               CHECK_FIELD (num, 15, -16, strict);
3394               num = low_sign_unext (num, 5);
3395               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3396
3397             /* Handle an unsigned 5 bit immediate at 31.  */
3398             case 'r':
3399               num = pa_get_absolute_expression (&the_insn, &s);
3400               if (strict && the_insn.exp.X_op != O_constant)
3401                 break;
3402               s = expr_end;
3403               CHECK_FIELD (num, 31, 0, strict);
3404               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3405
3406             /* Handle an unsigned 5 bit immediate at 15.  */
3407             case 'R':
3408               num = pa_get_absolute_expression (&the_insn, &s);
3409               if (strict && the_insn.exp.X_op != O_constant)
3410                 break;
3411               s = expr_end;
3412               CHECK_FIELD (num, 31, 0, strict);
3413               INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
3414
3415             /* Handle an unsigned 10 bit immediate at 15.  */
3416             case 'U':
3417               num = pa_get_absolute_expression (&the_insn, &s);
3418               if (strict && the_insn.exp.X_op != O_constant)
3419                 break;
3420               s = expr_end;
3421               CHECK_FIELD (num, 1023, 0, strict);
3422               INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
3423
3424             /* Handle a 2 bit space identifier at 17.  */
3425             case 's':
3426               if (!pa_parse_number (&s, 0))
3427                 break;
3428               num = pa_number;
3429               CHECK_FIELD (num, 3, 0, 1);
3430               INSERT_FIELD_AND_CONTINUE (opcode, num, 14);
3431
3432             /* Handle a 3 bit space identifier at 18.  */
3433             case 'S':
3434               if (!pa_parse_number (&s, 0))
3435                 break;
3436               num = pa_number;
3437               CHECK_FIELD (num, 7, 0, 1);
3438               opcode |= re_assemble_3 (num);
3439               continue;
3440
3441             /* Handle all completers.  */
3442             case 'c':
3443               switch (*++args)
3444                 {
3445
3446                 /* Handle a completer for an indexing load or store.  */
3447                 case 'X':
3448                 case 'x':
3449                   {
3450                     int uu = 0;
3451                     int m = 0;
3452                     int i = 0;
3453                     while (*s == ',' && i < 2)
3454                       {
3455                         s++;
3456                         if (strncasecmp (s, "sm", 2) == 0)
3457                           {
3458                             uu = 1;
3459                             m = 1;
3460                             s++;
3461                             i++;
3462                           }
3463                         else if (strncasecmp (s, "m", 1) == 0)
3464                           m = 1;
3465                         else if ((strncasecmp (s, "s ", 2) == 0)
3466                                  || (strncasecmp (s, "s,", 2) == 0))
3467                           uu = 1;
3468                         else if (strict)
3469                           {
3470                             /* This is a match failure.  */
3471                             s--;
3472                             break;
3473                           }
3474                         else
3475                           as_bad (_("Invalid Indexed Load Completer."));
3476                         s++;
3477                         i++;
3478                       }
3479                     if (i > 2)
3480                       as_bad (_("Invalid Indexed Load Completer Syntax."));
3481                     opcode |= m << 5;
3482                     INSERT_FIELD_AND_CONTINUE (opcode, uu, 13);
3483                   }
3484
3485                 /* Handle a short load/store completer.  */
3486                 case 'M':
3487                 case 'm':
3488                 case 'q':
3489                 case 'J':
3490                 case 'e':
3491                   {
3492                     int a = 0;
3493                     int m = 0;
3494                     if (*s == ',')
3495                       {
3496                         s++;
3497                         if (strncasecmp (s, "ma", 2) == 0)
3498                           {
3499                             a = 0;
3500                             m = 1;
3501                             s += 2;
3502                           }
3503                         else if (strncasecmp (s, "mb", 2) == 0)
3504                           {
3505                             a = 1;
3506                             m = 1;
3507                             s += 2;
3508                           }
3509                         else if (strict)
3510                           /* This is a match failure.  */
3511                           s--;
3512                         else
3513                           {
3514                             as_bad (_("Invalid Short Load/Store Completer."));
3515                             s += 2;
3516                           }
3517                       }
3518                     /* If we did not get a ma/mb completer, then we do not
3519                        consider this a positive match for 'ce'.  */
3520                     else if (*args == 'e')
3521                       break;
3522
3523                    /* 'J', 'm', 'M' and 'q' are the same, except for where they
3524                        encode the before/after field.  */
3525                    if (*args == 'm' || *args == 'M')
3526                       {
3527                         opcode |= m << 5;
3528                         INSERT_FIELD_AND_CONTINUE (opcode, a, 13);
3529                       }
3530                     else if (*args == 'q')
3531                       {
3532                         opcode |= m << 3;
3533                         INSERT_FIELD_AND_CONTINUE (opcode, a, 2);
3534                       }
3535                     else if (*args == 'J')
3536                       {
3537                         /* M bit is explicit in the major opcode.  */
3538                         INSERT_FIELD_AND_CONTINUE (opcode, a, 2);
3539                       }
3540                     else if (*args == 'e')
3541                       {
3542                         /* Stash the ma/mb flag temporarily in the
3543                            instruction.  We will use (and remove it)
3544                            later when handling 'J', 'K', '<' & '>'.  */
3545                         opcode |= a;
3546                         continue;
3547                       }
3548                   }
3549
3550                 /* Handle a stbys completer.  */
3551                 case 'A':
3552                 case 's':
3553                   {
3554                     int a = 0;
3555                     int m = 0;
3556                     int i = 0;
3557                     while (*s == ',' && i < 2)
3558                       {
3559                         s++;
3560                         if (strncasecmp (s, "m", 1) == 0)
3561                           m = 1;
3562                         else if ((strncasecmp (s, "b ", 2) == 0)
3563                                  || (strncasecmp (s, "b,", 2) == 0))
3564                           a = 0;
3565                         else if (strncasecmp (s, "e", 1) == 0)
3566                           a = 1;
3567                         /* In strict mode, this is a match failure.  */
3568                         else if (strict)
3569                           {
3570                             s--;
3571                             break;
3572                           }
3573                         else
3574                           as_bad (_("Invalid Store Bytes Short Completer"));
3575                         s++;
3576                         i++;
3577                       }
3578                     if (i > 2)
3579                       as_bad (_("Invalid Store Bytes Short Completer"));
3580                     opcode |= m << 5;
3581                     INSERT_FIELD_AND_CONTINUE (opcode, a, 13);
3582                   }
3583
3584                 /* Handle load cache hint completer.  */
3585                 case 'c':
3586                   cmpltr = 0;
3587                   if (!strncmp (s, ",sl", 3))
3588                     {
3589                       s += 3;
3590                       cmpltr = 2;
3591                     }
3592                   INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 10);
3593
3594                 /* Handle store cache hint completer.  */
3595                 case 'C':
3596                   cmpltr = 0;
3597                   if (!strncmp (s, ",sl", 3))
3598                     {
3599                       s += 3;
3600                       cmpltr = 2;
3601                     }
3602                   else if (!strncmp (s, ",bc", 3))
3603                     {
3604                       s += 3;
3605                       cmpltr = 1;
3606                     }
3607                   INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 10);
3608
3609                 /* Handle load and clear cache hint completer.  */
3610                 case 'd':
3611                   cmpltr = 0;
3612                   if (!strncmp (s, ",co", 3))
3613                     {
3614                       s += 3;
3615                       cmpltr = 1;
3616                     }
3617                   INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 10);
3618
3619                 /* Handle load ordering completer.  */
3620                 case 'o':
3621                   if (strncmp (s, ",o", 2) != 0)
3622                     break;
3623                   s += 2;
3624                   continue;
3625
3626                 /* Handle a branch gate completer.  */
3627                 case 'g':
3628                   if (strncasecmp (s, ",gate", 5) != 0)
3629                     break;
3630                   s += 5;
3631                   continue;
3632
3633                 /* Handle a branch link and push completer.  */
3634                 case 'p':
3635                   if (strncasecmp (s, ",l,push", 7) != 0)
3636                     break;
3637                   s += 7;
3638                   continue;
3639
3640                 /* Handle a branch link completer.  */
3641                 case 'l':
3642                   if (strncasecmp (s, ",l", 2) != 0)
3643                     break;
3644                   s += 2;
3645                   continue;
3646
3647                 /* Handle a branch pop completer.  */
3648                 case 'P':
3649                   if (strncasecmp (s, ",pop", 4) != 0)
3650                     break;
3651                   s += 4;
3652                   continue;
3653
3654                 /* Handle a local processor completer.  */
3655                 case 'L':
3656                   if (strncasecmp (s, ",l", 2) != 0)
3657                     break;
3658                   s += 2;
3659                   continue;
3660
3661                 /* Handle a PROBE read/write completer.  */
3662                 case 'w':
3663                   flag = 0;
3664                   if (!strncasecmp (s, ",w", 2))
3665                     {
3666                       flag = 1;
3667                       s += 2;
3668                     }
3669                   else if (!strncasecmp (s, ",r", 2))
3670                     {
3671                       flag = 0;
3672                       s += 2;
3673                     }
3674
3675                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 6);
3676
3677                 /* Handle MFCTL wide completer.  */
3678                 case 'W':
3679                   if (strncasecmp (s, ",w", 2) != 0)
3680                     break;
3681                   s += 2;
3682                   continue;
3683
3684                 /* Handle an RFI restore completer.  */
3685                 case 'r':
3686                   flag = 0;
3687                   if (!strncasecmp (s, ",r", 2))
3688                     {
3689                       flag = 5;
3690                       s += 2;
3691                     }
3692
3693                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 5);
3694
3695                 /* Handle a system control completer.  */
3696                 case 'Z':
3697                   if (*s == ',' && (*(s + 1) == 'm' || *(s + 1) == 'M'))
3698                     {
3699                       flag = 1;
3700                       s += 2;
3701                     }
3702                   else
3703                     flag = 0;
3704
3705                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 5);
3706
3707                 /* Handle intermediate/final completer for DCOR.  */
3708                 case 'i':
3709                   flag = 0;
3710                   if (!strncasecmp (s, ",i", 2))
3711                     {
3712                       flag = 1;
3713                       s += 2;
3714                     }
3715
3716                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 6);
3717
3718                 /* Handle zero/sign extension completer.  */
3719                 case 'z':
3720                   flag = 1;
3721                   if (!strncasecmp (s, ",z", 2))
3722                     {
3723                       flag = 0;
3724                       s += 2;
3725                     }
3726
3727                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 10);
3728
3729                 /* Handle add completer.  */
3730                 case 'a':
3731                   flag = 1;
3732                   if (!strncasecmp (s, ",l", 2))
3733                     {
3734                       flag = 2;
3735                       s += 2;
3736                     }
3737                   else if (!strncasecmp (s, ",tsv", 4))
3738                     {
3739                       flag = 3;
3740                       s += 4;
3741                     }
3742
3743                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 10);
3744
3745                 /* Handle 64 bit carry for ADD.  */
3746                 case 'Y':
3747                   flag = 0;
3748                   if (!strncasecmp (s, ",dc,tsv", 7) ||
3749                       !strncasecmp (s, ",tsv,dc", 7))
3750                     {
3751                       flag = 1;
3752                       s += 7;
3753                     }
3754                   else if (!strncasecmp (s, ",dc", 3))
3755                     {
3756                       flag = 0;
3757                       s += 3;
3758                     }
3759                   else
3760                     break;
3761
3762                   /* Condition is not required with "dc".  */
3763                   need_cond = 0;
3764                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3765
3766                 /* Handle 32 bit carry for ADD.  */
3767                 case 'y':
3768                   flag = 0;
3769                   if (!strncasecmp (s, ",c,tsv", 6) ||
3770                       !strncasecmp (s, ",tsv,c", 6))
3771                     {
3772                       flag = 1;
3773                       s += 6;
3774                     }
3775                   else if (!strncasecmp (s, ",c", 2))
3776                     {
3777                       flag = 0;
3778                       s += 2;
3779                     }
3780                   else
3781                     break;
3782
3783                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3784
3785                 /* Handle trap on signed overflow.  */
3786                 case 'v':
3787                   flag = 0;
3788                   if (!strncasecmp (s, ",tsv", 4))
3789                     {
3790                       flag = 1;
3791                       s += 4;
3792                     }
3793
3794                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3795
3796                 /* Handle trap on condition and overflow.  */
3797                 case 't':
3798                   flag = 0;
3799                   if (!strncasecmp (s, ",tc,tsv", 7) ||
3800                       !strncasecmp (s, ",tsv,tc", 7))
3801                     {
3802                       flag = 1;
3803                       s += 7;
3804                     }
3805                   else if (!strncasecmp (s, ",tc", 3))
3806                     {
3807                       flag = 0;
3808                       s += 3;
3809                     }
3810                   else
3811                     break;
3812
3813                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3814
3815                 /* Handle 64 bit borrow for SUB.  */
3816                 case 'B':
3817                   flag = 0;
3818                   if (!strncasecmp (s, ",db,tsv", 7) ||
3819                       !strncasecmp (s, ",tsv,db", 7))
3820                     {
3821                       flag = 1;
3822                       s += 7;
3823                     }
3824                   else if (!strncasecmp (s, ",db", 3))
3825                     {
3826                       flag = 0;
3827                       s += 3;
3828                     }
3829                   else
3830                     break;
3831
3832                   /* Condition is not required with "db".  */
3833                   need_cond = 0;
3834                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3835
3836                 /* Handle 32 bit borrow for SUB.  */
3837                 case 'b':
3838                   flag = 0;
3839                   if (!strncasecmp (s, ",b,tsv", 6) ||
3840                       !strncasecmp (s, ",tsv,b", 6))
3841                     {
3842                       flag = 1;
3843                       s += 6;
3844                     }
3845                   else if (!strncasecmp (s, ",b", 2))
3846                     {
3847                       flag = 0;
3848                       s += 2;
3849                     }
3850                   else
3851                     break;
3852
3853                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3854
3855                 /* Handle trap condition completer for UADDCM.  */
3856                 case 'T':
3857                   flag = 0;
3858                   if (!strncasecmp (s, ",tc", 3))
3859                     {
3860                       flag = 1;
3861                       s += 3;
3862                     }
3863
3864                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 6);
3865
3866                 /* Handle signed/unsigned at 21.  */
3867                 case 'S':
3868                   {
3869                     int sign = 1;
3870                     if (strncasecmp (s, ",s", 2) == 0)
3871                       {
3872                         sign = 1;
3873                         s += 2;
3874                       }
3875                     else if (strncasecmp (s, ",u", 2) == 0)
3876                       {
3877                         sign = 0;
3878                         s += 2;
3879                       }
3880
3881                     INSERT_FIELD_AND_CONTINUE (opcode, sign, 10);
3882                   }
3883
3884                 /* Handle left/right combination at 17:18.  */
3885                 case 'h':
3886                   if (*s++ == ',')
3887                     {
3888                       int lr = 0;
3889                       if (*s == 'r')
3890                         lr = 2;
3891                       else if (*s == 'l')
3892                         lr = 0;
3893                       else
3894                         as_bad (_("Invalid left/right combination completer"));
3895
3896                       s++;
3897                       INSERT_FIELD_AND_CONTINUE (opcode, lr, 13);
3898                     }
3899                   else
3900                     as_bad (_("Invalid left/right combination completer"));
3901                   break;
3902
3903                 /* Handle saturation at 24:25.  */
3904                 case 'H':
3905                   {
3906                     int sat = 3;
3907                     if (strncasecmp (s, ",ss", 3) == 0)
3908                       {
3909                         sat = 1;
3910                         s += 3;
3911                       }
3912                     else if (strncasecmp (s, ",us", 3) == 0)
3913                       {
3914                         sat = 0;
3915                         s += 3;
3916                       }
3917
3918                     INSERT_FIELD_AND_CONTINUE (opcode, sat, 6);
3919                   }
3920
3921                 /* Handle permutation completer.  */
3922                 case '*':
3923                   if (*s++ == ',')
3924                     {
3925                       int permloc[4];
3926                       int perm = 0;
3927                       int i = 0;
3928                       permloc[0] = 13;
3929                       permloc[1] = 10;
3930                       permloc[2] = 8;
3931                       permloc[3] = 6;
3932                       for (; i < 4; i++)
3933                         {
3934                           switch (*s++)
3935                             {
3936                             case '0':
3937                               perm = 0;
3938                               break;
3939                             case '1':
3940                               perm = 1;
3941                               break;
3942                             case '2':
3943                               perm = 2;
3944                               break;
3945                             case '3':
3946                               perm = 3;
3947                               break;
3948                             default:
3949                               as_bad (_("Invalid permutation completer"));
3950                             }
3951                           opcode |= perm << permloc[i];
3952                         }
3953                       continue;
3954                     }
3955                   else
3956                     as_bad (_("Invalid permutation completer"));
3957                   break;
3958
3959                 default:
3960                   abort ();
3961                 }
3962               break;
3963
3964             /* Handle all conditions.  */
3965             case '?':
3966               {
3967                 args++;
3968                 switch (*args)
3969                   {
3970                   /* Handle FP compare conditions.  */
3971                   case 'f':
3972                     cond = pa_parse_fp_cmp_cond (&s);
3973                     INSERT_FIELD_AND_CONTINUE (opcode, cond, 0);
3974
3975                   /* Handle an add condition.  */
3976                   case 'A':
3977                   case 'a':
3978                     cmpltr = 0;
3979                     flag = 0;
3980                     if (*s == ',')
3981                       {
3982                         s++;
3983
3984                         /* 64 bit conditions.  */
3985                         if (*args == 'A')
3986                           {
3987                             if (*s == '*')
3988                               s++;
3989                             else
3990                               break;
3991                           }
3992                         else if (*s == '*')
3993                           break;
3994
3995                         name = s;
3996                         while (*s != ',' && *s != ' ' && *s != '\t')
3997                           s += 1;
3998                         c = *s;
3999                         *s = 0x00;
4000                         if (strcmp (name, "=") == 0)
4001                           cmpltr = 1;
4002                         else if (strcmp (name, "<") == 0)
4003                           cmpltr = 2;
4004                         else if (strcmp (name, "<=") == 0)
4005                           cmpltr = 3;
4006                         else if (strcasecmp (name, "nuv") == 0)
4007                           cmpltr = 4;
4008                         else if (strcasecmp (name, "znv") == 0)
4009                           cmpltr = 5;
4010                         else if (strcasecmp (name, "sv") == 0)
4011                           cmpltr = 6;
4012                         else if (strcasecmp (name, "od") == 0)
4013                           cmpltr = 7;
4014                         else if (strcasecmp (name, "tr") == 0)
4015                           {
4016                             cmpltr = 0;
4017                             flag = 1;
4018                           }
4019                         else if (strcmp (name, "<>") == 0)
4020                           {
4021                             cmpltr = 1;
4022                             flag = 1;
4023                           }
4024                         else if (strcmp (name, ">=") == 0)
4025                           {
4026                             cmpltr = 2;
4027                             flag = 1;
4028                           }
4029                         else if (strcmp (name, ">") == 0)
4030                           {
4031                             cmpltr = 3;
4032                             flag = 1;
4033                           }
4034                         else if (strcasecmp (name, "uv") == 0)
4035                           {
4036                             cmpltr = 4;
4037                             flag = 1;
4038                           }
4039                         else if (strcasecmp (name, "vnz") == 0)
4040                           {
4041                             cmpltr = 5;
4042                             flag = 1;
4043                           }
4044                         else if (strcasecmp (name, "nsv") == 0)
4045                           {
4046                             cmpltr = 6;
4047                             flag = 1;
4048                           }
4049                         else if (strcasecmp (name, "ev") == 0)
4050                           {
4051                             cmpltr = 7;
4052                             flag = 1;
4053                           }
4054                         /* ",*" is a valid condition.  */
4055                         else if (*args == 'a' || *name)
4056                           as_bad (_("Invalid Add Condition: %s"), name);
4057                         *s = c;
4058                       }
4059                     /* Except with "dc", we have a match failure with
4060                        'A' if we don't have a doubleword condition.  */
4061                     else if (*args == 'A' && need_cond)
4062                       break;
4063
4064                     opcode |= cmpltr << 13;
4065                     INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
4066
4067                   /* Handle non-negated add and branch condition.  */
4068                   case 'd':
4069                     cmpltr = pa_parse_nonneg_add_cmpltr (&s);
4070                     if (cmpltr < 0)
4071                       {
4072                         as_bad (_("Invalid Add and Branch Condition"));
4073                         cmpltr = 0;
4074                       }
4075                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4076
4077                   /* Handle 64 bit wide-mode add and branch condition.  */
4078                   case 'W':
4079                     cmpltr = pa_parse_addb_64_cmpltr (&s);
4080                     if (cmpltr < 0)
4081                       {
4082                         as_bad (_("Invalid Add and Branch Condition"));
4083                         cmpltr = 0;
4084                       }
4085                     else
4086                       {
4087                         /* Negated condition requires an opcode change.  */
4088                         opcode |= (cmpltr & 8) << 24;
4089                       }
4090                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr & 7, 13);
4091
4092                   /* Handle a negated or non-negated add and branch
4093                      condition.  */
4094                   case '@':
4095                     save_s = s;
4096                     cmpltr = pa_parse_nonneg_add_cmpltr (&s);
4097                     if (cmpltr < 0)
4098                       {
4099                         s = save_s;
4100                         cmpltr = pa_parse_neg_add_cmpltr (&s);
4101                         if (cmpltr < 0)
4102                           {
4103                             as_bad (_("Invalid Compare/Subtract Condition"));
4104                             cmpltr = 0;
4105                           }
4106                         else
4107                           {
4108                             /* Negated condition requires an opcode change.  */
4109                             opcode |= 1 << 27;
4110                           }
4111                       }
4112                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4113
4114                   /* Handle branch on bit conditions.  */
4115                   case 'B':
4116                   case 'b':
4117                     cmpltr = 0;
4118                     if (*s == ',')
4119                       {
4120                         s++;
4121
4122                         if (*args == 'B')
4123                           {
4124                             if (*s == '*')
4125                               s++;
4126                             else
4127                               break;
4128                           }
4129                         else if (*s == '*')
4130                           break;
4131
4132                         if (strncmp (s, "<", 1) == 0)
4133                           {
4134                             cmpltr = 0;
4135                             s++;
4136                           }
4137                         else if (strncmp (s, ">=", 2) == 0)
4138                           {
4139                             cmpltr = 1;
4140                             s += 2;
4141                           }
4142                         else
4143                           as_bad (_("Invalid Branch On Bit Condition: %c"), *s);
4144                       }
4145                     else
4146                       as_bad (_("Missing Branch On Bit Condition"));
4147
4148                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 15);
4149
4150                   /* Handle a compare/subtract condition.  */
4151                   case 'S':
4152                   case 's':
4153                     cmpltr = 0;
4154                     flag = 0;
4155                     if (*s == ',')
4156                       {
4157                         s++;
4158
4159                         /* 64 bit conditions.  */
4160                         if (*args == 'S')
4161                           {
4162                             if (*s == '*')
4163                               s++;
4164                             else
4165                               break;
4166                           }
4167                         else if (*s == '*')
4168                           break;
4169
4170                         name = s;
4171                         while (*s != ',' && *s != ' ' && *s != '\t')
4172                           s += 1;
4173                         c = *s;
4174                         *s = 0x00;
4175                         if (strcmp (name, "=") == 0)
4176                           cmpltr = 1;
4177                         else if (strcmp (name, "<") == 0)
4178                           cmpltr = 2;
4179                         else if (strcmp (name, "<=") == 0)
4180                           cmpltr = 3;
4181                         else if (strcasecmp (name, "<<") == 0)
4182                           cmpltr = 4;
4183                         else if (strcasecmp (name, "<<=") == 0)
4184                           cmpltr = 5;
4185                         else if (strcasecmp (name, "sv") == 0)
4186                           cmpltr = 6;
4187                         else if (strcasecmp (name, "od") == 0)
4188                           cmpltr = 7;
4189                         else if (strcasecmp (name, "tr") == 0)
4190                           {
4191                             cmpltr = 0;
4192                             flag = 1;
4193                           }
4194                         else if (strcmp (name, "<>") == 0)
4195                           {
4196                             cmpltr = 1;
4197                             flag = 1;
4198                           }
4199                         else if (strcmp (name, ">=") == 0)
4200                           {
4201                             cmpltr = 2;
4202                             flag = 1;
4203                           }
4204                         else if (strcmp (name, ">") == 0)
4205                           {
4206                             cmpltr = 3;
4207                             flag = 1;
4208                           }
4209                         else if (strcasecmp (name, ">>=") == 0)
4210                           {
4211                             cmpltr = 4;
4212                             flag = 1;
4213                           }
4214                         else if (strcasecmp (name, ">>") == 0)
4215                           {
4216                             cmpltr = 5;
4217                             flag = 1;
4218                           }
4219                         else if (strcasecmp (name, "nsv") == 0)
4220                           {
4221                             cmpltr = 6;
4222                             flag = 1;
4223                           }
4224                         else if (strcasecmp (name, "ev") == 0)
4225                           {
4226                             cmpltr = 7;
4227                             flag = 1;
4228                           }
4229                         /* ",*" is a valid condition.  */
4230                         else if (*args != 'S' || *name)
4231                           as_bad (_("Invalid Compare/Subtract Condition: %s"),
4232                                   name);
4233                         *s = c;
4234                       }
4235                     /* Except with "db", we have a match failure with
4236                        'S' if we don't have a doubleword condition.  */
4237                     else if (*args == 'S' && need_cond)
4238                       break;
4239
4240                     opcode |= cmpltr << 13;
4241                     INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
4242
4243                   /* Handle a non-negated compare condition.  */
4244                   case 't':
4245                     cmpltr = pa_parse_nonneg_cmpsub_cmpltr (&s);
4246                     if (cmpltr < 0)
4247                       {
4248                         as_bad (_("Invalid Compare/Subtract Condition"));
4249                         cmpltr = 0;
4250                       }
4251                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4252
4253                   /* Handle a 32 bit compare and branch condition.  */
4254                   case 'n':
4255                     save_s = s;
4256                     cmpltr = pa_parse_nonneg_cmpsub_cmpltr (&s);
4257                     if (cmpltr < 0)
4258                       {
4259                         s = save_s;
4260                         cmpltr = pa_parse_neg_cmpsub_cmpltr (&s);
4261                         if (cmpltr < 0)
4262                           {
4263                             as_bad (_("Invalid Compare and Branch Condition"));
4264                             cmpltr = 0;
4265                           }
4266                         else
4267                           {
4268                             /* Negated condition requires an opcode change.  */
4269                             opcode |= 1 << 27;
4270                           }
4271                       }
4272
4273                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4274
4275                   /* Handle a 64 bit compare and branch condition.  */
4276                   case 'N':
4277                     cmpltr = pa_parse_cmpb_64_cmpltr (&s);
4278                     if (cmpltr >= 0)
4279                       {
4280                         /* Negated condition requires an opcode change.  */
4281                         opcode |= (cmpltr & 8) << 26;
4282                       }
4283                     else
4284                       /* Not a 64 bit cond.  Give 32 bit a chance.  */
4285                       break;
4286
4287                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr & 7, 13);
4288
4289                   /* Handle a 64 bit cmpib condition.  */
4290                   case 'Q':
4291                     cmpltr = pa_parse_cmpib_64_cmpltr (&s);
4292                     if (cmpltr < 0)
4293                       /* Not a 64 bit cond.  Give 32 bit a chance.  */
4294                       break;
4295
4296                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4297
4298                   /* Handle a logical instruction condition.  */
4299                   case 'L':
4300                   case 'l':
4301                     cmpltr = 0;
4302                     flag = 0;
4303                     if (*s == ',')
4304                       {
4305                         s++;
4306
4307                         /* 64 bit conditions.  */
4308                         if (*args == 'L')
4309                           {
4310                             if (*s == '*')
4311                               s++;
4312                             else
4313                               break;
4314                           }
4315                         else if (*s == '*')
4316                           break;
4317
4318                         name = s;
4319                         while (*s != ',' && *s != ' ' && *s != '\t')
4320                           s += 1;
4321                         c = *s;
4322                         *s = 0x00;
4323
4324                         if (strcmp (name, "=") == 0)
4325                           cmpltr = 1;
4326                         else if (strcmp (name, "<") == 0)
4327                           cmpltr = 2;
4328                         else if (strcmp (name, "<=") == 0)
4329                           cmpltr = 3;
4330                         else if (strcasecmp (name, "od") == 0)
4331                           cmpltr = 7;
4332                         else if (strcasecmp (name, "tr") == 0)
4333                           {
4334                             cmpltr = 0;
4335                             flag = 1;
4336                           }
4337                         else if (strcmp (name, "<>") == 0)
4338                           {
4339                             cmpltr = 1;
4340                             flag = 1;
4341                           }
4342                         else if (strcmp (name, ">=") == 0)
4343                           {
4344                             cmpltr = 2;
4345                             flag = 1;
4346                           }
4347                         else if (strcmp (name, ">") == 0)
4348                           {
4349                             cmpltr = 3;
4350                             flag = 1;
4351                           }
4352                         else if (strcasecmp (name, "ev") == 0)
4353                           {
4354                             cmpltr = 7;
4355                             flag = 1;
4356                           }
4357                         /* ",*" is a valid condition.  */
4358                         else if (*args != 'L' || *name)
4359                           as_bad (_("Invalid Logical Instruction Condition."));
4360                         *s = c;
4361                       }
4362                     /* 32-bit is default for no condition.  */
4363                     else if (*args == 'L')
4364                       break;
4365
4366                     opcode |= cmpltr << 13;
4367                     INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
4368
4369                   /* Handle a shift/extract/deposit condition.  */
4370                   case 'X':
4371                   case 'x':
4372                   case 'y':
4373                     cmpltr = 0;
4374                     /* Check immediate values in shift/extract/deposit
4375                      * instructions if they will give undefined behaviour.  */
4376                     immediate_check = 1;
4377                     if (*s == ',')
4378                       {
4379                         save_s = s++;
4380
4381                         /* 64 bit conditions.  */
4382                         if (*args == 'X')
4383                           {
4384                             if (*s == '*')
4385                               s++;
4386                             else
4387                               break;
4388                           }
4389                         else if (*s == '*')
4390                           break;
4391
4392                         name = s;
4393                         while (*s != ',' && *s != ' ' && *s != '\t')
4394                           s += 1;
4395                         c = *s;
4396                         *s = 0x00;
4397                         if (strcmp (name, "=") == 0)
4398                           cmpltr = 1;
4399                         else if (strcmp (name, "<") == 0)
4400                           cmpltr = 2;
4401                         else if (strcasecmp (name, "od") == 0)
4402                           cmpltr = 3;
4403                         else if (strcasecmp (name, "tr") == 0)
4404                           cmpltr = 4;
4405                         else if (strcmp (name, "<>") == 0)
4406                           cmpltr = 5;
4407                         else if (strcmp (name, ">=") == 0)
4408                           cmpltr = 6;
4409                         else if (strcasecmp (name, "ev") == 0)
4410                           cmpltr = 7;
4411                         /* Handle movb,n.  Put things back the way they were.
4412                            This includes moving s back to where it started.  */
4413                         else if (strcasecmp (name, "n") == 0 && *args == 'y')
4414                           {
4415                             *s = c;
4416                             s = save_s;
4417                             continue;
4418                           }
4419                         /* ",*" is a valid condition.  */
4420                         else if (*args != 'X' || *name)
4421                           as_bad (_("Invalid Shift/Extract/Deposit Condition."));
4422                         *s = c;
4423                       }
4424
4425                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4426
4427                   /* Handle a unit instruction condition.  */
4428                   case 'U':
4429                   case 'u':
4430                     cmpltr = 0;
4431                     flag = 0;
4432                     if (*s == ',')
4433                       {
4434                         s++;
4435
4436                         /* 64 bit conditions.  */
4437                         if (*args == 'U')
4438                           {
4439                             if (*s == '*')
4440                               s++;
4441                             else
4442                               break;
4443                           }
4444                         else if (*s == '*')
4445                           break;
4446
4447                         if (strncasecmp (s, "sbz", 3) == 0)
4448                           {
4449                             cmpltr = 2;
4450                             s += 3;
4451                           }
4452                         else if (strncasecmp (s, "shz", 3) == 0)
4453                           {
4454                             cmpltr = 3;
4455                             s += 3;
4456                           }
4457                         else if (strncasecmp (s, "sdc", 3) == 0)
4458                           {
4459                             cmpltr = 4;
4460                             s += 3;
4461                           }
4462                         else if (strncasecmp (s, "sbc", 3) == 0)
4463                           {
4464                             cmpltr = 6;
4465                             s += 3;
4466                           }
4467                         else if (strncasecmp (s, "shc", 3) == 0)
4468                           {
4469                             cmpltr = 7;
4470                             s += 3;
4471                           }
4472                         else if (strncasecmp (s, "tr", 2) == 0)
4473                           {
4474                             cmpltr = 0;
4475                             flag = 1;
4476                             s += 2;
4477                           }
4478                         else if (strncasecmp (s, "nbz", 3) == 0)
4479                           {
4480                             cmpltr = 2;
4481                             flag = 1;
4482                             s += 3;
4483                           }
4484                         else if (strncasecmp (s, "nhz", 3) == 0)
4485                           {
4486                             cmpltr = 3;
4487                             flag = 1;
4488                             s += 3;
4489                           }
4490                         else if (strncasecmp (s, "ndc", 3) == 0)
4491                           {
4492                             cmpltr = 4;
4493                             flag = 1;
4494                             s += 3;
4495                           }
4496                         else if (strncasecmp (s, "nbc", 3) == 0)
4497                           {
4498                             cmpltr = 6;
4499                             flag = 1;
4500                             s += 3;
4501                           }
4502                         else if (strncasecmp (s, "nhc", 3) == 0)
4503                           {
4504                             cmpltr = 7;
4505                             flag = 1;
4506                             s += 3;
4507                           }
4508                         else if (strncasecmp (s, "swz", 3) == 0)
4509                           {
4510                             cmpltr = 1;
4511                             flag = 0;
4512                             s += 3;
4513                           }
4514                         else if (strncasecmp (s, "swc", 3) == 0)
4515                           {
4516                             cmpltr = 5;
4517                             flag = 0;
4518                             s += 3;
4519                           }
4520                         else if (strncasecmp (s, "nwz", 3) == 0)
4521                           {
4522                             cmpltr = 1;
4523                             flag = 1;
4524                             s += 3;
4525                           }
4526                         else if (strncasecmp (s, "nwc", 3) == 0)
4527                           {
4528                             cmpltr = 5;
4529                             flag = 1;
4530                             s += 3;
4531                           }
4532                         /* ",*" is a valid condition.  */
4533                         else if (*args != 'U' || (*s != ' ' && *s != '\t'))
4534                           as_bad (_("Invalid Unit Instruction Condition."));
4535                       }
4536                     /* 32-bit is default for no condition.  */
4537                     else if (*args == 'U')
4538                       break;
4539
4540                     opcode |= cmpltr << 13;
4541                     INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
4542
4543                   default:
4544                     abort ();
4545                   }
4546                 break;
4547               }
4548
4549             /* Handle a nullification completer for branch instructions.  */
4550             case 'n':
4551               nullif = pa_parse_nullif (&s);
4552               INSERT_FIELD_AND_CONTINUE (opcode, nullif, 1);
4553
4554             /* Handle a nullification completer for copr and spop insns.  */
4555             case 'N':
4556               nullif = pa_parse_nullif (&s);
4557               INSERT_FIELD_AND_CONTINUE (opcode, nullif, 5);
4558
4559             /* Handle ,%r2 completer for new syntax branches.  */
4560             case 'L':
4561               if (*s == ',' && strncasecmp (s + 1, "%r2", 3) == 0)
4562                 s += 4;
4563               else if (*s == ',' && strncasecmp (s + 1, "%rp", 3) == 0)
4564                 s += 4;
4565               else
4566                 break;
4567               continue;
4568
4569             /* Handle 3 bit entry into the fp compare array.   Valid values
4570                are 0..6 inclusive.  */
4571             case 'h':
4572               get_expression (s);
4573               s = expr_end;
4574               if (the_insn.exp.X_op == O_constant)
4575                 {
4576                   num = evaluate_absolute (&the_insn);
4577                   CHECK_FIELD (num, 6, 0, 0);
4578                   num++;
4579                   INSERT_FIELD_AND_CONTINUE (opcode, num, 13);
4580                 }
4581               else
4582                 break;
4583
4584             /* Handle 3 bit entry into the fp compare array.   Valid values
4585                are 0..6 inclusive.  */
4586             case 'm':
4587               get_expression (s);
4588               if (the_insn.exp.X_op == O_constant)
4589                 {
4590                   s = expr_end;
4591                   num = evaluate_absolute (&the_insn);
4592                   CHECK_FIELD (num, 6, 0, 0);
4593                   num = (num + 1) ^ 1;
4594                   INSERT_FIELD_AND_CONTINUE (opcode, num, 13);
4595                 }
4596               else
4597                 break;
4598
4599             /* Handle graphics test completers for ftest */
4600             case '=':
4601               {
4602                 num = pa_parse_ftest_gfx_completer (&s);
4603                 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4604               }
4605
4606             /* Handle a 11 bit immediate at 31.  */
4607             case 'i':
4608               the_insn.field_selector = pa_chk_field_selector (&s);
4609               get_expression (s);
4610               s = expr_end;
4611               if (the_insn.exp.X_op == O_constant)
4612                 {
4613                   num = evaluate_absolute (&the_insn);
4614                   CHECK_FIELD (num, 1023, -1024, 0);
4615                   num = low_sign_unext (num, 11);
4616                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4617                 }
4618               else
4619                 {
4620                   if (is_DP_relative (the_insn.exp))
4621                     the_insn.reloc = R_HPPA_GOTOFF;
4622                   else if (is_PC_relative (the_insn.exp))
4623                     the_insn.reloc = R_HPPA_PCREL_CALL;
4624 #ifdef OBJ_ELF
4625                   else if (is_tls_gdidx (the_insn.exp))
4626                     the_insn.reloc = R_PARISC_TLS_GD21L;
4627                   else if (is_tls_ldidx (the_insn.exp))
4628                     the_insn.reloc = R_PARISC_TLS_LDM21L;
4629                   else if (is_tls_dtpoff (the_insn.exp))
4630                     the_insn.reloc = R_PARISC_TLS_LDO21L;
4631                   else if (is_tls_ieoff (the_insn.exp))
4632                     the_insn.reloc = R_PARISC_TLS_IE21L;
4633                   else if (is_tls_leoff (the_insn.exp))
4634                     the_insn.reloc = R_PARISC_TLS_LE21L;
4635 #endif
4636                   else
4637                     the_insn.reloc = R_HPPA;
4638                   the_insn.format = 11;
4639                   continue;
4640                 }
4641
4642             /* Handle a 14 bit immediate at 31.  */
4643             case 'J':
4644               the_insn.field_selector = pa_chk_field_selector (&s);
4645               get_expression (s);
4646               s = expr_end;
4647               if (the_insn.exp.X_op == O_constant)
4648                 {
4649                   int mb;
4650
4651                   /* XXX the completer stored away tidbits of information
4652                      for us to extract.  We need a cleaner way to do this.
4653                      Now that we have lots of letters again, it would be
4654                      good to rethink this.  */
4655                   mb = opcode & 1;
4656                   opcode -= mb;
4657                   num = evaluate_absolute (&the_insn);
4658                   if (mb != (num < 0))
4659                     break;
4660                   CHECK_FIELD (num, 8191, -8192, 0);
4661                   num = low_sign_unext (num, 14);
4662                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4663                 }
4664               break;
4665
4666             /* Handle a 14 bit immediate at 31.  */
4667             case 'K':
4668               the_insn.field_selector = pa_chk_field_selector (&s);
4669               get_expression (s);
4670               s = expr_end;
4671               if (the_insn.exp.X_op == O_constant)
4672                 {
4673                   int mb;
4674
4675                   mb = opcode & 1;
4676                   opcode -= mb;
4677                   num = evaluate_absolute (&the_insn);
4678                   if (mb == (num < 0))
4679                     break;
4680                   if (num % 4)
4681                     break;
4682                   CHECK_FIELD (num, 8191, -8192, 0);
4683                   num = low_sign_unext (num, 14);
4684                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4685                 }
4686               break;
4687
4688             /* Handle a 16 bit immediate at 31.  */
4689             case '<':
4690               the_insn.field_selector = pa_chk_field_selector (&s);
4691               get_expression (s);
4692               s = expr_end;
4693               if (the_insn.exp.X_op == O_constant)
4694                 {
4695                   int mb;
4696
4697                   mb = opcode & 1;
4698                   opcode -= mb;
4699                   num = evaluate_absolute (&the_insn);
4700                   if (mb != (num < 0))
4701                     break;
4702                   CHECK_FIELD (num, 32767, -32768, 0);
4703                   num = re_assemble_16 (num);
4704                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4705                 }
4706               break;
4707
4708             /* Handle a 16 bit immediate at 31.  */
4709             case '>':
4710               the_insn.field_selector = pa_chk_field_selector (&s);
4711               get_expression (s);
4712               s = expr_end;
4713               if (the_insn.exp.X_op == O_constant)
4714                 {
4715                   int mb;
4716
4717                   mb = opcode & 1;
4718                   opcode -= mb;
4719                   num = evaluate_absolute (&the_insn);
4720                   if (mb == (num < 0))
4721                     break;
4722                   if (num % 4)
4723                     break;
4724                   CHECK_FIELD (num, 32767, -32768, 0);
4725                   num = re_assemble_16 (num);
4726                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4727                 }
4728               break;
4729
4730             /* Handle 14 bit immediate, shifted left three times.  */
4731             case '#':
4732               if (bfd_get_mach (stdoutput) != pa20)
4733                 break;
4734               the_insn.field_selector = pa_chk_field_selector (&s);
4735               get_expression (s);
4736               s = expr_end;
4737               if (the_insn.exp.X_op == O_constant)
4738                 {
4739                   num = evaluate_absolute (&the_insn);
4740                   if (num & 0x7)
4741                     break;
4742                   CHECK_FIELD (num, 8191, -8192, 0);
4743                   if (num < 0)
4744                     opcode |= 1;
4745                   num &= 0x1fff;
4746                   num >>= 3;
4747                   INSERT_FIELD_AND_CONTINUE (opcode, num, 4);
4748                 }
4749               else
4750                 {
4751                   if (is_DP_relative (the_insn.exp))
4752                     the_insn.reloc = R_HPPA_GOTOFF;
4753                   else if (is_PC_relative (the_insn.exp))
4754                     the_insn.reloc = R_HPPA_PCREL_CALL;
4755 #ifdef OBJ_ELF
4756                   else if (is_tls_gdidx (the_insn.exp))
4757                     the_insn.reloc = R_PARISC_TLS_GD21L;
4758                   else if (is_tls_ldidx (the_insn.exp))
4759                     the_insn.reloc = R_PARISC_TLS_LDM21L;
4760                   else if (is_tls_dtpoff (the_insn.exp))
4761                     the_insn.reloc = R_PARISC_TLS_LDO21L;
4762                   else if (is_tls_ieoff (the_insn.exp))
4763                     the_insn.reloc = R_PARISC_TLS_IE21L;
4764                   else if (is_tls_leoff (the_insn.exp))
4765                     the_insn.reloc = R_PARISC_TLS_LE21L;
4766 #endif
4767                   else
4768                     the_insn.reloc = R_HPPA;
4769                   the_insn.format = 14;
4770                   continue;
4771                 }
4772               break;
4773
4774             /* Handle 14 bit immediate, shifted left twice.  */
4775             case 'd':
4776               the_insn.field_selector = pa_chk_field_selector (&s);
4777               get_expression (s);
4778               s = expr_end;
4779               if (the_insn.exp.X_op == O_constant)
4780                 {
4781                   num = evaluate_absolute (&the_insn);
4782                   if (num & 0x3)
4783                     break;
4784                   CHECK_FIELD (num, 8191, -8192, 0);
4785                   if (num < 0)
4786                     opcode |= 1;
4787                   num &= 0x1fff;
4788                   num >>= 2;
4789                   INSERT_FIELD_AND_CONTINUE (opcode, num, 3);
4790                 }
4791               else
4792                 {
4793                   if (is_DP_relative (the_insn.exp))
4794                     the_insn.reloc = R_HPPA_GOTOFF;
4795                   else if (is_PC_relative (the_insn.exp))
4796                     the_insn.reloc = R_HPPA_PCREL_CALL;
4797 #ifdef OBJ_ELF
4798                   else if (is_tls_gdidx (the_insn.exp))
4799                     the_insn.reloc = R_PARISC_TLS_GD21L;
4800                   else if (is_tls_ldidx (the_insn.exp))
4801                     the_insn.reloc = R_PARISC_TLS_LDM21L;
4802                   else if (is_tls_dtpoff (the_insn.exp))
4803                     the_insn.reloc = R_PARISC_TLS_LDO21L;
4804                   else if (is_tls_ieoff (the_insn.exp))
4805                     the_insn.reloc = R_PARISC_TLS_IE21L;
4806                   else if (is_tls_leoff (the_insn.exp))
4807                     the_insn.reloc = R_PARISC_TLS_LE21L;
4808 #endif
4809                   else
4810                     the_insn.reloc = R_HPPA;
4811                   the_insn.format = 14;
4812                   continue;
4813                 }
4814
4815             /* Handle a 14 bit immediate at 31.  */
4816             case 'j':
4817               the_insn.field_selector = pa_chk_field_selector (&s);
4818               get_expression (s);
4819               s = expr_end;
4820               if (the_insn.exp.X_op == O_constant)
4821                 {
4822                   num = evaluate_absolute (&the_insn);
4823                   CHECK_FIELD (num, 8191, -8192, 0);
4824                   num = low_sign_unext (num, 14);
4825                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4826                 }
4827               else
4828                 {
4829                   if (is_DP_relative (the_insn.exp))
4830                     the_insn.reloc = R_HPPA_GOTOFF;
4831                   else if (is_PC_relative (the_insn.exp))
4832                     the_insn.reloc = R_HPPA_PCREL_CALL;
4833 #ifdef OBJ_ELF
4834                   else if (is_tls_gdidx (the_insn.exp))
4835                     the_insn.reloc = R_PARISC_TLS_GD21L;
4836                   else if (is_tls_ldidx (the_insn.exp))
4837                     the_insn.reloc = R_PARISC_TLS_LDM21L;
4838                   else if (is_tls_dtpoff (the_insn.exp))
4839                     the_insn.reloc = R_PARISC_TLS_LDO21L;
4840                   else if (is_tls_ieoff (the_insn.exp))
4841                     the_insn.reloc = R_PARISC_TLS_IE21L;
4842                   else if (is_tls_leoff (the_insn.exp))
4843                     the_insn.reloc = R_PARISC_TLS_LE21L;
4844 #endif
4845                   else
4846                     the_insn.reloc = R_HPPA;
4847                   the_insn.format = 14;
4848                   continue;
4849                 }
4850
4851             /* Handle a 21 bit immediate at 31.  */
4852             case 'k':
4853               the_insn.field_selector = pa_chk_field_selector (&s);
4854               get_expression (s);
4855               s = expr_end;
4856               if (the_insn.exp.X_op == O_constant)
4857                 {
4858                   num = evaluate_absolute (&the_insn);
4859                   CHECK_FIELD (num >> 11, 1048575, -1048576, 0);
4860                   opcode |= re_assemble_21 (num);
4861                   continue;
4862                 }
4863               else
4864                 {
4865                   if (is_DP_relative (the_insn.exp))
4866                     the_insn.reloc = R_HPPA_GOTOFF;
4867                   else if (is_PC_relative (the_insn.exp))
4868                     the_insn.reloc = R_HPPA_PCREL_CALL;
4869 #ifdef OBJ_ELF
4870                   else if (is_tls_gdidx (the_insn.exp))
4871                     the_insn.reloc = R_PARISC_TLS_GD21L;
4872                   else if (is_tls_ldidx (the_insn.exp))
4873                     the_insn.reloc = R_PARISC_TLS_LDM21L;
4874                   else if (is_tls_dtpoff (the_insn.exp))
4875                     the_insn.reloc = R_PARISC_TLS_LDO21L;
4876                   else if (is_tls_ieoff (the_insn.exp))
4877                     the_insn.reloc = R_PARISC_TLS_IE21L;
4878                   else if (is_tls_leoff (the_insn.exp))
4879                     the_insn.reloc = R_PARISC_TLS_LE21L;
4880 #endif
4881                   else
4882                     the_insn.reloc = R_HPPA;
4883                   the_insn.format = 21;
4884                   continue;
4885                 }
4886
4887             /* Handle a 16 bit immediate at 31 (PA 2.0 wide mode only).  */
4888             case 'l':
4889               the_insn.field_selector = pa_chk_field_selector (&s);
4890               get_expression (s);
4891               s = expr_end;
4892               if (the_insn.exp.X_op == O_constant)
4893                 {
4894                   num = evaluate_absolute (&the_insn);
4895                   CHECK_FIELD (num, 32767, -32768, 0);
4896                   opcode |= re_assemble_16 (num);
4897                   continue;
4898                 }
4899               else
4900                 {
4901                   /* ??? Is this valid for wide mode?  */
4902                   if (is_DP_relative (the_insn.exp))
4903                     the_insn.reloc = R_HPPA_GOTOFF;
4904                   else if (is_PC_relative (the_insn.exp))
4905                     the_insn.reloc = R_HPPA_PCREL_CALL;
4906 #ifdef OBJ_ELF
4907                   else if (is_tls_gdidx (the_insn.exp))
4908                     the_insn.reloc = R_PARISC_TLS_GD21L;
4909                   else if (is_tls_ldidx (the_insn.exp))
4910                     the_insn.reloc = R_PARISC_TLS_LDM21L;
4911                   else if (is_tls_dtpoff (the_insn.exp))
4912                     the_insn.reloc = R_PARISC_TLS_LDO21L;
4913                   else if (is_tls_ieoff (the_insn.exp))
4914                     the_insn.reloc = R_PARISC_TLS_IE21L;
4915                   else if (is_tls_leoff (the_insn.exp))
4916                     the_insn.reloc = R_PARISC_TLS_LE21L;
4917 #endif
4918                   else
4919                     the_insn.reloc = R_HPPA;
4920                   the_insn.format = 14;
4921                   continue;
4922                 }
4923
4924             /* Handle a word-aligned 16-bit imm. at 31 (PA2.0 wide).  */
4925             case 'y':
4926               the_insn.field_selector = pa_chk_field_selector (&s);
4927               get_expression (s);
4928               s = expr_end;
4929               if (the_insn.exp.X_op == O_constant)
4930                 {
4931                   num = evaluate_absolute (&the_insn);
4932                   CHECK_FIELD (num, 32767, -32768, 0);
4933                   CHECK_ALIGN (num, 4, 0);
4934                   opcode |= re_assemble_16 (num);
4935                   continue;
4936                 }
4937               else
4938                 {
4939                   /* ??? Is this valid for wide mode?  */
4940                   if (is_DP_relative (the_insn.exp))
4941                     the_insn.reloc = R_HPPA_GOTOFF;
4942                   else if (is_PC_relative (the_insn.exp))
4943                     the_insn.reloc = R_HPPA_PCREL_CALL;
4944 #ifdef OBJ_ELF
4945                   else if (is_tls_gdidx (the_insn.exp))
4946                     the_insn.reloc = R_PARISC_TLS_GD21L;
4947                   else if (is_tls_ldidx (the_insn.exp))
4948                     the_insn.reloc = R_PARISC_TLS_LDM21L;
4949                   else if (is_tls_dtpoff (the_insn.exp))
4950                     the_insn.reloc = R_PARISC_TLS_LDO21L;
4951                   else if (is_tls_ieoff (the_insn.exp))
4952                     the_insn.reloc = R_PARISC_TLS_IE21L;
4953                   else if (is_tls_leoff (the_insn.exp))
4954                     the_insn.reloc = R_PARISC_TLS_LE21L;
4955 #endif
4956                   else
4957                     the_insn.reloc = R_HPPA;
4958                   the_insn.format = 14;
4959                   continue;
4960                 }
4961
4962             /* Handle a dword-aligned 16-bit imm. at 31 (PA2.0 wide).  */
4963             case '&':
4964               the_insn.field_selector = pa_chk_field_selector (&s);
4965               get_expression (s);
4966               s = expr_end;
4967               if (the_insn.exp.X_op == O_constant)
4968                 {
4969                   num = evaluate_absolute (&the_insn);
4970                   CHECK_FIELD (num, 32767, -32768, 0);
4971                   CHECK_ALIGN (num, 8, 0);
4972                   opcode |= re_assemble_16 (num);
4973                   continue;
4974                 }
4975               else
4976                 {
4977                   /* ??? Is this valid for wide mode?  */
4978                   if (is_DP_relative (the_insn.exp))
4979                     the_insn.reloc = R_HPPA_GOTOFF;
4980                   else if (is_PC_relative (the_insn.exp))
4981                     the_insn.reloc = R_HPPA_PCREL_CALL;
4982 #ifdef OBJ_ELF
4983                   else if (is_tls_gdidx (the_insn.exp))
4984                     the_insn.reloc = R_PARISC_TLS_GD21L;
4985                   else if (is_tls_ldidx (the_insn.exp))
4986                     the_insn.reloc = R_PARISC_TLS_LDM21L;
4987                   else if (is_tls_dtpoff (the_insn.exp))
4988                     the_insn.reloc = R_PARISC_TLS_LDO21L;
4989                   else if (is_tls_ieoff (the_insn.exp))
4990                     the_insn.reloc = R_PARISC_TLS_IE21L;
4991                   else if (is_tls_leoff (the_insn.exp))
4992                     the_insn.reloc = R_PARISC_TLS_LE21L;
4993 #endif
4994                   else
4995                     the_insn.reloc = R_HPPA;
4996                   the_insn.format = 14;
4997                   continue;
4998                 }
4999
5000             /* Handle a 12 bit branch displacement.  */
5001             case 'w':
5002               the_insn.field_selector = pa_chk_field_selector (&s);
5003               get_expression (s);
5004               s = expr_end;
5005               the_insn.pcrel = 1;
5006               if (!the_insn.exp.X_add_symbol
5007                   || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
5008                               FAKE_LABEL_NAME))
5009                 {
5010                   num = evaluate_absolute (&the_insn);
5011                   if (num % 4)
5012                     {
5013                       as_bad (_("Branch to unaligned address"));
5014                       break;
5015                     }
5016                   if (the_insn.exp.X_add_symbol)
5017                     num -= 8;
5018                   CHECK_FIELD (num, 8191, -8192, 0);
5019                   opcode |= re_assemble_12 (num >> 2);
5020                   continue;
5021                 }
5022               else
5023                 {
5024                   the_insn.reloc = R_HPPA_PCREL_CALL;
5025                   the_insn.format = 12;
5026                   the_insn.arg_reloc = last_call_desc.arg_reloc;
5027                   memset (&last_call_desc, 0, sizeof (struct call_desc));
5028                   s = expr_end;
5029                   continue;
5030                 }
5031
5032             /* Handle a 17 bit branch displacement.  */
5033             case 'W':
5034               the_insn.field_selector = pa_chk_field_selector (&s);
5035               get_expression (s);
5036               s = expr_end;
5037               the_insn.pcrel = 1;
5038               if (!the_insn.exp.X_add_symbol
5039                   || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
5040                               FAKE_LABEL_NAME))
5041                 {
5042                   num = evaluate_absolute (&the_insn);
5043                   if (num % 4)
5044                     {
5045                       as_bad (_("Branch to unaligned address"));
5046                       break;
5047                     }
5048                   if (the_insn.exp.X_add_symbol)
5049                     num -= 8;
5050                   CHECK_FIELD (num, 262143, -262144, 0);
5051                   opcode |= re_assemble_17 (num >> 2);
5052                   continue;
5053                 }
5054               else
5055                 {
5056                   the_insn.reloc = R_HPPA_PCREL_CALL;
5057                   the_insn.format = 17;
5058                   the_insn.arg_reloc = last_call_desc.arg_reloc;
5059                   memset (&last_call_desc, 0, sizeof (struct call_desc));
5060                   continue;
5061                 }
5062
5063             /* Handle a 22 bit branch displacement.  */
5064             case 'X':
5065               the_insn.field_selector = pa_chk_field_selector (&s);
5066               get_expression (s);
5067               s = expr_end;
5068               the_insn.pcrel = 1;
5069               if (!the_insn.exp.X_add_symbol
5070                   || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
5071                               FAKE_LABEL_NAME))
5072                 {
5073                   num = evaluate_absolute (&the_insn);
5074                   if (num % 4)
5075                     {
5076                       as_bad (_("Branch to unaligned address"));
5077                       break;
5078                     }
5079                   if (the_insn.exp.X_add_symbol)
5080                     num -= 8;
5081                   CHECK_FIELD (num, 8388607, -8388608, 0);
5082                   opcode |= re_assemble_22 (num >> 2);
5083                 }
5084               else
5085                 {
5086                   the_insn.reloc = R_HPPA_PCREL_CALL;
5087                   the_insn.format = 22;
5088                   the_insn.arg_reloc = last_call_desc.arg_reloc;
5089                   memset (&last_call_desc, 0, sizeof (struct call_desc));
5090                   continue;
5091                 }
5092
5093             /* Handle an absolute 17 bit branch target.  */
5094             case 'z':
5095               the_insn.field_selector = pa_chk_field_selector (&s);
5096               get_expression (s);
5097               s = expr_end;
5098               the_insn.pcrel = 0;
5099               if (!the_insn.exp.X_add_symbol
5100                   || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
5101                               FAKE_LABEL_NAME))
5102                 {
5103                   num = evaluate_absolute (&the_insn);
5104                   if (num % 4)
5105                     {
5106                       as_bad (_("Branch to unaligned address"));
5107                       break;
5108                     }
5109                   if (the_insn.exp.X_add_symbol)
5110                     num -= 8;
5111                   CHECK_FIELD (num, 262143, -262144, 0);
5112                   opcode |= re_assemble_17 (num >> 2);
5113                   continue;
5114                 }
5115               else
5116                 {
5117                   the_insn.reloc = R_HPPA_ABS_CALL;
5118                   the_insn.format = 17;
5119                   the_insn.arg_reloc = last_call_desc.arg_reloc;
5120                   memset (&last_call_desc, 0, sizeof (struct call_desc));
5121                   continue;
5122                 }
5123
5124             /* Handle '%r1' implicit operand of addil instruction.  */
5125             case 'Z':
5126               if (*s == ',' && *(s + 1) == '%' && *(s + 3) == '1'
5127                   && (*(s + 2) == 'r' || *(s + 2) == 'R'))
5128                 {
5129                   s += 4;
5130                   continue;
5131                 }
5132               else
5133                 break;
5134
5135             /* Handle '%sr0,%r31' implicit operand of be,l instruction.  */
5136             case 'Y':
5137               if (strncasecmp (s, "%sr0,%r31", 9) != 0)
5138                 break;
5139               s += 9;
5140               continue;
5141
5142             /* Handle immediate value of 0 for ordered load/store instructions.  */
5143             case '@':
5144               if (*s != '0')
5145                 break;
5146               s++;
5147               continue;
5148
5149             /* Handle a 2 bit shift count at 25.  */
5150             case '.':
5151               num = pa_get_absolute_expression (&the_insn, &s);
5152               if (strict && the_insn.exp.X_op != O_constant)
5153                 break;
5154               s = expr_end;
5155               CHECK_FIELD (num, 3, 1, strict);
5156               INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
5157
5158             /* Handle a 4 bit shift count at 25.  */
5159             case '*':
5160               num = pa_get_absolute_expression (&the_insn, &s);
5161               if (strict && the_insn.exp.X_op != O_constant)
5162                 break;
5163               s = expr_end;
5164               CHECK_FIELD (num, 15, 0, strict);
5165               INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
5166
5167             /* Handle a 5 bit shift count at 26.  */
5168             case 'p':
5169               num = pa_get_absolute_expression (&the_insn, &s);
5170               if (strict && the_insn.exp.X_op != O_constant)
5171                 break;
5172               s = expr_end;
5173               CHECK_FIELD (num, 31, 0, strict);
5174               SAVE_IMMEDIATE(num);
5175               INSERT_FIELD_AND_CONTINUE (opcode, 31 - num, 5);
5176
5177             /* Handle a 6 bit shift count at 20,22:26.  */
5178             case '~':
5179               num = pa_get_absolute_expression (&the_insn, &s);
5180               if (strict && the_insn.exp.X_op != O_constant)
5181                 break;
5182               s = expr_end;
5183               CHECK_FIELD (num, 63, 0, strict);
5184               SAVE_IMMEDIATE(num);
5185               num = 63 - num;
5186               opcode |= (num & 0x20) << 6;
5187               INSERT_FIELD_AND_CONTINUE (opcode, num & 0x1f, 5);
5188
5189             /* Handle a 6 bit field length at 23,27:31.  */
5190             case '%':
5191               flag = 0;
5192               num = pa_get_absolute_expression (&the_insn, &s);
5193               if (strict && the_insn.exp.X_op != O_constant)
5194                 break;
5195               s = expr_end;
5196               CHECK_FIELD (num, 64, 1, strict);
5197               SAVE_IMMEDIATE(num);
5198               num--;
5199               opcode |= (num & 0x20) << 3;
5200               num = 31 - (num & 0x1f);
5201               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5202
5203             /* Handle a 6 bit field length at 19,27:31.  */
5204             case '|':
5205               num = pa_get_absolute_expression (&the_insn, &s);
5206               if (strict && the_insn.exp.X_op != O_constant)
5207                 break;
5208               s = expr_end;
5209               CHECK_FIELD (num, 64, 1, strict);
5210               SAVE_IMMEDIATE(num);
5211               num--;
5212               opcode |= (num & 0x20) << 7;
5213               num = 31 - (num & 0x1f);
5214               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5215
5216             /* Handle a 5 bit bit position at 26.  */
5217             case 'P':
5218               num = pa_get_absolute_expression (&the_insn, &s);
5219               if (strict && the_insn.exp.X_op != O_constant)
5220                 break;
5221               s = expr_end;
5222               CHECK_FIELD (num, 31, 0, strict);
5223               SAVE_IMMEDIATE(num);
5224               INSERT_FIELD_AND_CONTINUE (opcode, num, 5);
5225
5226             /* Handle a 6 bit bit position at 20,22:26.  */
5227             case 'q':
5228               num = pa_get_absolute_expression (&the_insn, &s);
5229               if (strict && the_insn.exp.X_op != O_constant)
5230                 break;
5231               s = expr_end;
5232               CHECK_FIELD (num, 63, 0, strict);
5233               SAVE_IMMEDIATE(num);
5234               opcode |= (num & 0x20) << 6;
5235               INSERT_FIELD_AND_CONTINUE (opcode, num & 0x1f, 5);
5236
5237             /* Handle a 5 bit immediate at 10 with 'd' as the complement
5238                of the high bit of the immediate.  */
5239             case 'B':
5240               num = pa_get_absolute_expression (&the_insn, &s);
5241               if (strict && the_insn.exp.X_op != O_constant)
5242                 break;
5243               s = expr_end;
5244               CHECK_FIELD (num, 63, 0, strict);
5245               if (num & 0x20)
5246                 ;
5247               else
5248                 opcode |= (1 << 13);
5249               INSERT_FIELD_AND_CONTINUE (opcode, num & 0x1f, 21);
5250
5251             /* Handle a 5 bit immediate at 10.  */
5252             case 'Q':
5253               num = pa_get_absolute_expression (&the_insn, &s);
5254               if (strict && the_insn.exp.X_op != O_constant)
5255                 break;
5256               s = expr_end;
5257               CHECK_FIELD (num, 31, 0, strict);
5258               INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
5259
5260             /* Handle a 9 bit immediate at 28.  */
5261             case '$':
5262               num = pa_get_absolute_expression (&the_insn, &s);
5263               if (strict && the_insn.exp.X_op != O_constant)
5264                 break;
5265               s = expr_end;
5266               CHECK_FIELD (num, 511, 1, strict);
5267               INSERT_FIELD_AND_CONTINUE (opcode, num, 3);
5268
5269             /* Handle a 13 bit immediate at 18.  */
5270             case 'A':
5271               num = pa_get_absolute_expression (&the_insn, &s);
5272               if (strict && the_insn.exp.X_op != O_constant)
5273                 break;
5274               s = expr_end;
5275               CHECK_FIELD (num, 8191, 0, strict);
5276               INSERT_FIELD_AND_CONTINUE (opcode, num, 13);
5277
5278             /* Handle a 26 bit immediate at 31.  */
5279             case 'D':
5280               num = pa_get_absolute_expression (&the_insn, &s);
5281               if (strict && the_insn.exp.X_op != O_constant)
5282                 break;
5283               s = expr_end;
5284               CHECK_FIELD (num, 67108863, 0, strict);
5285               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5286
5287             /* Handle a 3 bit SFU identifier at 25.  */
5288             case 'v':
5289               if (*s++ != ',')
5290                 as_bad (_("Invalid SFU identifier"));
5291               num = pa_get_absolute_expression (&the_insn, &s);
5292               if (strict && the_insn.exp.X_op != O_constant)
5293                 break;
5294               s = expr_end;
5295               CHECK_FIELD (num, 7, 0, strict);
5296               INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
5297
5298             /* Handle a 20 bit SOP field for spop0.  */
5299             case 'O':
5300               num = pa_get_absolute_expression (&the_insn, &s);
5301               if (strict && the_insn.exp.X_op != O_constant)
5302                 break;
5303               s = expr_end;
5304               CHECK_FIELD (num, 1048575, 0, strict);
5305               num = (num & 0x1f) | ((num & 0x000fffe0) << 6);
5306               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5307
5308             /* Handle a 15bit SOP field for spop1.  */
5309             case 'o':
5310               num = pa_get_absolute_expression (&the_insn, &s);
5311               if (strict && the_insn.exp.X_op != O_constant)
5312                 break;
5313               s = expr_end;
5314               CHECK_FIELD (num, 32767, 0, strict);
5315               INSERT_FIELD_AND_CONTINUE (opcode, num, 11);
5316
5317             /* Handle a 10bit SOP field for spop3.  */
5318             case '0':
5319               num = pa_get_absolute_expression (&the_insn, &s);
5320               if (strict && the_insn.exp.X_op != O_constant)
5321                 break;
5322               s = expr_end;
5323               CHECK_FIELD (num, 1023, 0, strict);
5324               num = (num & 0x1f) | ((num & 0x000003e0) << 6);
5325               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5326
5327             /* Handle a 15 bit SOP field for spop2.  */
5328             case '1':
5329               num = pa_get_absolute_expression (&the_insn, &s);
5330               if (strict && the_insn.exp.X_op != O_constant)
5331                 break;
5332               s = expr_end;
5333               CHECK_FIELD (num, 32767, 0, strict);
5334               num = (num & 0x1f) | ((num & 0x00007fe0) << 6);
5335               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5336
5337             /* Handle a 3-bit co-processor ID field.  */
5338             case 'u':
5339               if (*s++ != ',')
5340                 as_bad (_("Invalid COPR identifier"));
5341               num = pa_get_absolute_expression (&the_insn, &s);
5342               if (strict && the_insn.exp.X_op != O_constant)
5343                 break;
5344               s = expr_end;
5345               CHECK_FIELD (num, 7, 0, strict);
5346               INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
5347
5348             /* Handle a 22bit SOP field for copr.  */
5349             case '2':
5350               num = pa_get_absolute_expression (&the_insn, &s);
5351               if (strict && the_insn.exp.X_op != O_constant)
5352                 break;
5353               s = expr_end;
5354               CHECK_FIELD (num, 4194303, 0, strict);
5355               num = (num & 0x1f) | ((num & 0x003fffe0) << 4);
5356               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5357
5358             /* Handle a source FP operand format completer.  */
5359             case '{':
5360               if (*s == ',' && *(s+1) == 't')
5361                 {
5362                   the_insn.trunc = 1;
5363                   s += 2;
5364                 }
5365               else
5366                 the_insn.trunc = 0;
5367               flag = pa_parse_fp_cnv_format (&s);
5368               the_insn.fpof1 = flag;
5369               if (flag == W || flag == UW)
5370                 flag = SGL;
5371               if (flag == DW || flag == UDW)
5372                 flag = DBL;
5373               if (flag == QW || flag == UQW)
5374                 flag = QUAD;
5375               INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
5376
5377             /* Handle a destination FP operand format completer.  */
5378             case '_':
5379               /* pa_parse_format needs the ',' prefix.  */
5380               s--;
5381               flag = pa_parse_fp_cnv_format (&s);
5382               the_insn.fpof2 = flag;
5383               if (flag == W || flag == UW)
5384                 flag = SGL;
5385               if (flag == DW || flag == UDW)
5386                 flag = DBL;
5387               if (flag == QW || flag == UQW)
5388                 flag = QUAD;
5389               opcode |= flag << 13;
5390               if (the_insn.fpof1 == SGL
5391                   || the_insn.fpof1 == DBL
5392                   || the_insn.fpof1 == QUAD)
5393                 {
5394                   if (the_insn.fpof2 == SGL
5395                       || the_insn.fpof2 == DBL
5396                       || the_insn.fpof2 == QUAD)
5397                     flag = 0;
5398                   else if (the_insn.fpof2 == W
5399                       || the_insn.fpof2 == DW
5400                       || the_insn.fpof2 == QW)
5401                     flag = 2;
5402                   else if (the_insn.fpof2 == UW
5403                       || the_insn.fpof2 == UDW
5404                       || the_insn.fpof2 == UQW)
5405                     flag = 6;
5406                   else
5407                     abort ();
5408                 }
5409               else if (the_insn.fpof1 == W
5410                        || the_insn.fpof1 == DW
5411                        || the_insn.fpof1 == QW)
5412                 {
5413                   if (the_insn.fpof2 == SGL
5414                       || the_insn.fpof2 == DBL
5415                       || the_insn.fpof2 == QUAD)
5416                     flag = 1;
5417                   else
5418                     abort ();
5419                 }
5420               else if (the_insn.fpof1 == UW
5421                        || the_insn.fpof1 == UDW
5422                        || the_insn.fpof1 == UQW)
5423                 {
5424                   if (the_insn.fpof2 == SGL
5425                       || the_insn.fpof2 == DBL
5426                       || the_insn.fpof2 == QUAD)
5427                     flag = 5;
5428                   else
5429                     abort ();
5430                 }
5431               flag |= the_insn.trunc;
5432               INSERT_FIELD_AND_CONTINUE (opcode, flag, 15);
5433
5434             /* Handle a source FP operand format completer.  */
5435             case 'F':
5436               flag = pa_parse_fp_format (&s);
5437               the_insn.fpof1 = flag;
5438               INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
5439
5440             /* Handle a destination FP operand format completer.  */
5441             case 'G':
5442               /* pa_parse_format needs the ',' prefix.  */
5443               s--;
5444               flag = pa_parse_fp_format (&s);
5445               the_insn.fpof2 = flag;
5446               INSERT_FIELD_AND_CONTINUE (opcode, flag, 13);
5447
5448             /* Handle a source FP operand format completer at 20.  */
5449             case 'I':
5450               flag = pa_parse_fp_format (&s);
5451               the_insn.fpof1 = flag;
5452               INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
5453
5454             /* Handle a floating point operand format at 26.
5455                Only allows single and double precision.  */
5456             case 'H':
5457               flag = pa_parse_fp_format (&s);
5458               switch (flag)
5459                 {
5460                 case SGL:
5461                   opcode |= 0x20;
5462                 case DBL:
5463                   the_insn.fpof1 = flag;
5464                   continue;
5465
5466                 case QUAD:
5467                 case ILLEGAL_FMT:
5468                 default:
5469                   as_bad (_("Invalid Floating Point Operand Format."));
5470                 }
5471               break;
5472
5473             /* Handle all floating point registers.  */
5474             case 'f':
5475               switch (*++args)
5476                 {
5477                 /* Float target register.  */
5478                 case 't':
5479                   if (!pa_parse_number (&s, 3))
5480                     break;
5481                   num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5482                   CHECK_FIELD (num, 31, 0, 0);
5483                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5484
5485                 /* Float target register with L/R selection.  */
5486                 case 'T':
5487                   {
5488                     if (!pa_parse_number (&s, 1))
5489                       break;
5490                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5491                     CHECK_FIELD (num, 31, 0, 0);
5492                     opcode |= num;
5493
5494                     /* 0x30 opcodes are FP arithmetic operation opcodes
5495                        and need to be turned into 0x38 opcodes.  This
5496                        is not necessary for loads/stores.  */
5497                     if (need_pa11_opcode ()
5498                         && ((opcode & 0xfc000000) == 0x30000000))
5499                       opcode |= 1 << 27;
5500
5501                     opcode |= (pa_number & FP_REG_RSEL ? 1 << 6 : 0);
5502                     continue;
5503                   }
5504
5505                 /* Float operand 1.  */
5506                 case 'a':
5507                   {
5508                     if (!pa_parse_number (&s, 1))
5509                       break;
5510                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5511                     CHECK_FIELD (num, 31, 0, 0);
5512                     opcode |= num << 21;
5513                     if (need_pa11_opcode ())
5514                       {
5515                         opcode |= (pa_number & FP_REG_RSEL ? 1 << 7 : 0);
5516                         opcode |= 1 << 27;
5517                       }
5518                     continue;
5519                   }
5520
5521                 /* Float operand 1 with L/R selection.  */
5522                 case 'X':
5523                 case 'A':
5524                   {
5525                     if (!pa_parse_number (&s, 1))
5526                       break;
5527                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5528                     CHECK_FIELD (num, 31, 0, 0);
5529                     opcode |= num << 21;
5530                     opcode |= (pa_number & FP_REG_RSEL ? 1 << 7 : 0);
5531                     continue;
5532                   }
5533
5534                 /* Float operand 2.  */
5535                 case 'b':
5536                   {
5537                     if (!pa_parse_number (&s, 1))
5538                       break;
5539                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5540                     CHECK_FIELD (num, 31, 0, 0);
5541                     opcode |= num << 16;
5542                     if (need_pa11_opcode ())
5543                       {
5544                         opcode |= (pa_number & FP_REG_RSEL ? 1 << 12 : 0);
5545                         opcode |= 1 << 27;
5546                       }
5547                     continue;
5548                   }
5549
5550                 /* Float operand 2 with L/R selection.  */
5551                 case 'B':
5552                   {
5553                     if (!pa_parse_number (&s, 1))
5554                       break;
5555                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5556                     CHECK_FIELD (num, 31, 0, 0);
5557                     opcode |= num << 16;
5558                     opcode |= (pa_number & FP_REG_RSEL ? 1 << 12 : 0);
5559                     continue;
5560                   }
5561
5562                 /* Float operand 3 for fmpyfadd, fmpynfadd.  */
5563                 case 'C':
5564                   {
5565                     if (!pa_parse_number (&s, 1))
5566                       break;
5567                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5568                     CHECK_FIELD (num, 31, 0, 0);
5569                     opcode |= (num & 0x1c) << 11;
5570                     opcode |= (num & 0x03) << 9;
5571                     opcode |= (pa_number & FP_REG_RSEL ? 1 << 8 : 0);
5572                     continue;
5573                   }
5574
5575                 /* Float mult operand 1 for fmpyadd, fmpysub */
5576                 case 'i':
5577                   {
5578                     if (!pa_parse_number (&s, 1))
5579                       break;
5580                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5581                     CHECK_FIELD (num, 31, 0, 0);
5582                     if (the_insn.fpof1 == SGL)
5583                       {
5584                         if (num < 16)
5585                           {
5586                             as_bad  (_("Invalid register for single precision fmpyadd or fmpysub"));
5587                             break;
5588                           }
5589                         num &= 0xF;
5590                         num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
5591                       }
5592                     INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
5593                   }
5594
5595                 /* Float mult operand 2 for fmpyadd, fmpysub */
5596                 case 'j':
5597                   {
5598                     if (!pa_parse_number (&s, 1))
5599                       break;
5600                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5601                     CHECK_FIELD (num, 31, 0, 0);
5602                     if (the_insn.fpof1 == SGL)
5603                       {
5604                         if (num < 16)
5605                           {
5606                             as_bad  (_("Invalid register for single precision fmpyadd or fmpysub"));
5607                             break;
5608                           }
5609                         num &= 0xF;
5610                         num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
5611                       }
5612                     INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
5613                   }
5614
5615                 /* Float mult target for fmpyadd, fmpysub */
5616                 case 'k':
5617                   {
5618                     if (!pa_parse_number (&s, 1))
5619                       break;
5620                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5621                     CHECK_FIELD (num, 31, 0, 0);
5622                     if (the_insn.fpof1 == SGL)
5623                       {
5624                         if (num < 16)
5625                           {
5626                             as_bad  (_("Invalid register for single precision fmpyadd or fmpysub"));
5627                             break;
5628                           }
5629                         num &= 0xF;
5630                         num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
5631                       }
5632                     INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5633                   }
5634
5635                 /* Float add operand 1 for fmpyadd, fmpysub */
5636                 case 'l':
5637                   {
5638                     if (!pa_parse_number (&s, 1))
5639                       break;
5640                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5641                     CHECK_FIELD (num, 31, 0, 0);
5642                     if (the_insn.fpof1 == SGL)
5643                       {
5644                         if (num < 16)
5645                           {
5646                             as_bad  (_("Invalid register for single precision fmpyadd or fmpysub"));
5647                             break;
5648                           }
5649                         num &= 0xF;
5650                         num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
5651                       }
5652                     INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
5653                   }
5654
5655                 /* Float add target for fmpyadd, fmpysub */
5656                 case 'm':
5657                   {
5658                     if (!pa_parse_number (&s, 1))
5659                       break;
5660                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5661                     CHECK_FIELD (num, 31, 0, 0);
5662                     if (the_insn.fpof1 == SGL)
5663                       {
5664                         if (num < 16)
5665                           {
5666                             as_bad  (_("Invalid register for single precision fmpyadd or fmpysub"));
5667                             break;
5668                           }
5669                         num &= 0xF;
5670                         num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
5671                       }
5672                     INSERT_FIELD_AND_CONTINUE (opcode, num, 11);
5673                   }
5674
5675                 /* Handle L/R register halves like 'x'.  */
5676                 case 'E':
5677                 case 'e':
5678                   {
5679                     if (!pa_parse_number (&s, 1))
5680                       break;
5681                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5682                     CHECK_FIELD (num, 31, 0, 0);
5683                     opcode |= num << 16;
5684                     if (need_pa11_opcode ())
5685                       {
5686                         opcode |= (pa_number & FP_REG_RSEL ? 1 << 1 : 0);
5687                       }
5688                     continue;
5689                   }
5690
5691                 /* Float target register (PA 2.0 wide).  */
5692                 case 'x':
5693                   if (!pa_parse_number (&s, 3))
5694                     break;
5695                   num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5696                   CHECK_FIELD (num, 31, 0, 0);
5697                   INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
5698
5699                 default:
5700                   abort ();
5701                 }
5702               break;
5703
5704             default:
5705               abort ();
5706             }
5707           break;
5708         }
5709
5710       /* If this instruction is specific to a particular architecture,
5711          then set a new architecture.  This automatic promotion crud is
5712          for compatibility with HP's old assemblers only.  */
5713       if (match == TRUE
5714           && bfd_get_mach (stdoutput) < insn->arch
5715           && !bfd_set_arch_mach (stdoutput, bfd_arch_hppa, insn->arch))
5716         {
5717           as_warn (_("could not update architecture and machine"));
5718           match = FALSE;
5719         }
5720
5721  failed:
5722       /* Check if the args matched.  */
5723       if (!match)
5724         {
5725           if (&insn[1] - pa_opcodes < (int) NUMOPCODES
5726               && !strcmp (insn->name, insn[1].name))
5727             {
5728               ++insn;
5729               s = argstart;
5730               continue;
5731             }
5732           else
5733             {
5734               as_bad (_("Invalid operands %s"), error_message);
5735               return;
5736             }
5737         }
5738       break;
5739     }
5740
5741   if (immediate_check)
5742     {
5743       if (pos != -1 && len != -1 && pos < len - 1)
5744         as_warn (_("Immediates %d and %d will give undefined behavior."),
5745                         pos, len);
5746     }
5747
5748   the_insn.opcode = opcode;
5749 }
5750
5751 /* Assemble a single instruction storing it into a frag.  */
5752
5753 void
5754 md_assemble (char *str)
5755 {
5756   char *to;
5757
5758   /* The had better be something to assemble.  */
5759   gas_assert (str);
5760
5761   /* If we are within a procedure definition, make sure we've
5762      defined a label for the procedure; handle case where the
5763      label was defined after the .PROC directive.
5764
5765      Note there's not need to diddle with the segment or fragment
5766      for the label symbol in this case.  We have already switched
5767      into the new $CODE$ subspace at this point.  */
5768   if (within_procedure && last_call_info->start_symbol == NULL)
5769     {
5770       label_symbol_struct *label_symbol = pa_get_label ();
5771
5772       if (label_symbol)
5773         {
5774           if (label_symbol->lss_label)
5775             {
5776               last_call_info->start_symbol = label_symbol->lss_label;
5777               symbol_get_bfdsym (label_symbol->lss_label)->flags
5778                 |= BSF_FUNCTION;
5779 #ifdef OBJ_SOM
5780               /* Also handle allocation of a fixup to hold the unwind
5781                  information when the label appears after the proc/procend.  */
5782               if (within_entry_exit)
5783                 {
5784                   char *where;
5785                   unsigned int u;
5786
5787                   where = frag_more (0);
5788                   u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
5789                   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
5790                                 NULL, (offsetT) 0, NULL,
5791                                 0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
5792                 }
5793 #endif
5794             }
5795           else
5796             as_bad (_("Missing function name for .PROC (corrupted label chain)"));
5797         }
5798       else
5799         as_bad (_("Missing function name for .PROC"));
5800     }
5801
5802   /* Assemble the instruction.  Results are saved into "the_insn".  */
5803   pa_ip (str);
5804
5805   /* Get somewhere to put the assembled instruction.  */
5806   to = frag_more (4);
5807
5808   /* Output the opcode.  */
5809   md_number_to_chars (to, the_insn.opcode, 4);
5810
5811   /* If necessary output more stuff.  */
5812   if (the_insn.reloc != R_HPPA_NONE)
5813     fix_new_hppa (frag_now, (to - frag_now->fr_literal), 4, NULL,
5814                   (offsetT) 0, &the_insn.exp, the_insn.pcrel,
5815                   the_insn.reloc, the_insn.field_selector,
5816                   the_insn.format, the_insn.arg_reloc, 0);
5817
5818 #ifdef OBJ_ELF
5819   dwarf2_emit_insn (4);
5820 #endif
5821 }
5822
5823 #ifdef OBJ_SOM
5824 /* Handle an alignment directive.  Special so that we can update the
5825    alignment of the subspace if necessary.  */
5826 static void
5827 pa_align (int bytes)
5828 {
5829   /* We must have a valid space and subspace.  */
5830   pa_check_current_space_and_subspace ();
5831
5832   /* Let the generic gas code do most of the work.  */
5833   s_align_bytes (bytes);
5834
5835   /* If bytes is a power of 2, then update the current subspace's
5836      alignment if necessary.  */
5837   if (exact_log2 (bytes) != -1)
5838     record_alignment (current_subspace->ssd_seg, exact_log2 (bytes));
5839 }
5840 #endif
5841
5842 /* Handle a .BLOCK type pseudo-op.  */
5843
5844 static void
5845 pa_block (int z ATTRIBUTE_UNUSED)
5846 {
5847   unsigned int temp_size;
5848
5849 #ifdef OBJ_SOM
5850   /* We must have a valid space and subspace.  */
5851   pa_check_current_space_and_subspace ();
5852 #endif
5853
5854   temp_size = get_absolute_expression ();
5855
5856   if (temp_size > 0x3FFFFFFF)
5857     {
5858       as_bad (_("Argument to .BLOCK/.BLOCKZ must be between 0 and 0x3fffffff"));
5859       temp_size = 0;
5860     }
5861   else
5862     {
5863       /* Always fill with zeros, that's what the HP assembler does.  */
5864       char *p = frag_var (rs_fill, 1, 1, 0, NULL, temp_size, NULL);
5865       *p = 0;
5866     }
5867
5868   pa_undefine_label ();
5869   demand_empty_rest_of_line ();
5870 }
5871
5872 /* Handle a .begin_brtab and .end_brtab pseudo-op.  */
5873
5874 static void
5875 pa_brtab (int begin ATTRIBUTE_UNUSED)
5876 {
5877
5878 #ifdef OBJ_SOM
5879   /* The BRTAB relocations are only available in SOM (to denote
5880      the beginning and end of branch tables).  */
5881   char *where = frag_more (0);
5882
5883   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
5884                 NULL, (offsetT) 0, NULL,
5885                 0, begin ? R_HPPA_BEGIN_BRTAB : R_HPPA_END_BRTAB,
5886                 e_fsel, 0, 0, 0);
5887 #endif
5888
5889   demand_empty_rest_of_line ();
5890 }
5891
5892 /* Handle a .begin_try and .end_try pseudo-op.  */
5893
5894 static void
5895 pa_try (int begin ATTRIBUTE_UNUSED)
5896 {
5897 #ifdef OBJ_SOM
5898   expressionS exp;
5899   char *where = frag_more (0);
5900
5901   if (! begin)
5902     expression (&exp);
5903
5904   /* The TRY relocations are only available in SOM (to denote
5905      the beginning and end of exception handling regions).  */
5906
5907   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
5908                 NULL, (offsetT) 0, begin ? NULL : &exp,
5909                 0, begin ? R_HPPA_BEGIN_TRY : R_HPPA_END_TRY,
5910                 e_fsel, 0, 0, 0);
5911 #endif
5912
5913   demand_empty_rest_of_line ();
5914 }
5915
5916 /* Do the dirty work of building a call descriptor which describes
5917    where the caller placed arguments to a function call.  */
5918
5919 static void
5920 pa_call_args (struct call_desc *call_desc)
5921 {
5922   char *name, c, *p;
5923   unsigned int temp, arg_reloc;
5924
5925   while (!is_end_of_statement ())
5926     {
5927       name = input_line_pointer;
5928       c = get_symbol_end ();
5929       /* Process a source argument.  */
5930       if ((strncasecmp (name, "argw", 4) == 0))
5931         {
5932           temp = atoi (name + 4);
5933           p = input_line_pointer;
5934           *p = c;
5935           input_line_pointer++;
5936           name = input_line_pointer;
5937           c = get_symbol_end ();
5938           arg_reloc = pa_build_arg_reloc (name);
5939           call_desc->arg_reloc |= pa_align_arg_reloc (temp, arg_reloc);
5940         }
5941       /* Process a return value.  */
5942       else if ((strncasecmp (name, "rtnval", 6) == 0))
5943         {
5944           p = input_line_pointer;
5945           *p = c;
5946           input_line_pointer++;
5947           name = input_line_pointer;
5948           c = get_symbol_end ();
5949           arg_reloc = pa_build_arg_reloc (name);
5950           call_desc->arg_reloc |= (arg_reloc & 0x3);
5951         }
5952       else
5953         {
5954           as_bad (_("Invalid .CALL argument: %s"), name);
5955         }
5956       p = input_line_pointer;
5957       *p = c;
5958       if (!is_end_of_statement ())
5959         input_line_pointer++;
5960     }
5961 }
5962
5963 /* Handle a .CALL pseudo-op.  This involves storing away information
5964    about where arguments are to be found so the linker can detect
5965    (and correct) argument location mismatches between caller and callee.  */
5966
5967 static void
5968 pa_call (int unused ATTRIBUTE_UNUSED)
5969 {
5970 #ifdef OBJ_SOM
5971   /* We must have a valid space and subspace.  */
5972   pa_check_current_space_and_subspace ();
5973 #endif
5974
5975   pa_call_args (&last_call_desc);
5976   demand_empty_rest_of_line ();
5977 }
5978
5979 #ifdef OBJ_ELF
5980 /* Build an entry in the UNWIND subspace from the given function
5981    attributes in CALL_INFO.  This is not needed for SOM as using
5982    R_ENTRY and R_EXIT relocations allow the linker to handle building
5983    of the unwind spaces.  */
5984
5985 static void
5986 pa_build_unwind_subspace (struct call_info *call_info)
5987 {
5988   asection *seg, *save_seg;
5989   subsegT save_subseg;
5990   unsigned int unwind;
5991   int reloc;
5992   char *name, *p;
5993   symbolS *symbolP;
5994
5995   if ((bfd_get_section_flags (stdoutput, now_seg)
5996        & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
5997       != (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
5998     return;
5999
6000   if (call_info->start_symbol == NULL)
6001     /* This can happen if there were errors earlier on in the assembly.  */
6002     return;
6003
6004   /* Replace the start symbol with a local symbol that will be reduced
6005      to a section offset.  This avoids problems with weak functions with
6006      multiple definitions, etc.  */
6007   name = xmalloc (strlen ("L$\001start_")
6008                   + strlen (S_GET_NAME (call_info->start_symbol))
6009                   + 1);
6010   strcpy (name, "L$\001start_");
6011   strcat (name, S_GET_NAME (call_info->start_symbol));
6012
6013   /* If we have a .procend preceded by a .exit, then the symbol will have
6014      already been defined.  In that case, we don't want another unwind
6015      entry.  */
6016   symbolP = symbol_find (name);
6017   if (symbolP)
6018     {
6019       xfree (name);
6020       return;
6021     }
6022   else
6023     {
6024       symbolP = symbol_new (name, now_seg,
6025                             S_GET_VALUE (call_info->start_symbol), frag_now);
6026       gas_assert (symbolP);
6027       S_CLEAR_EXTERNAL (symbolP);
6028       symbol_table_insert (symbolP);
6029     }
6030
6031   reloc = R_PARISC_SEGREL32;
6032   save_seg = now_seg;
6033   save_subseg = now_subseg;
6034   /* Get into the right seg/subseg.  This may involve creating
6035      the seg the first time through.  Make sure to have the
6036      old seg/subseg so that we can reset things when we are done.  */
6037   seg = bfd_get_section_by_name (stdoutput, UNWIND_SECTION_NAME);
6038   if (seg == ASEC_NULL)
6039     {
6040       seg = subseg_new (UNWIND_SECTION_NAME, 0);
6041       bfd_set_section_flags (stdoutput, seg,
6042                              SEC_READONLY | SEC_HAS_CONTENTS
6043                              | SEC_LOAD | SEC_RELOC | SEC_ALLOC | SEC_DATA);
6044       bfd_set_section_alignment (stdoutput, seg, 2);
6045     }
6046
6047   subseg_set (seg, 0);
6048
6049   /* Get some space to hold relocation information for the unwind
6050      descriptor.  */
6051   p = frag_more (16);
6052
6053   /* Relocation info. for start offset of the function.  */
6054   md_number_to_chars (p, 0, 4);
6055   fix_new_hppa (frag_now, p - frag_now->fr_literal, 4,
6056                 symbolP, (offsetT) 0,
6057                 (expressionS *) NULL, 0, reloc,
6058                 e_fsel, 32, 0, 0);
6059
6060   /* Relocation info. for end offset of the function.
6061
6062      Because we allow reductions of 32bit relocations for ELF, this will be
6063      reduced to section_sym + offset which avoids putting the temporary
6064      symbol into the symbol table.  It (should) end up giving the same
6065      value as call_info->start_symbol + function size once the linker is
6066      finished with its work.  */
6067   md_number_to_chars (p + 4, 0, 4);
6068   fix_new_hppa (frag_now, p + 4 - frag_now->fr_literal, 4,
6069                 call_info->end_symbol, (offsetT) 0,
6070                 (expressionS *) NULL, 0, reloc,
6071                 e_fsel, 32, 0, 0);
6072
6073   /* Dump the descriptor.  */
6074   unwind = UNWIND_LOW32 (&call_info->ci_unwind.descriptor);
6075   md_number_to_chars (p + 8, unwind, 4);
6076
6077   unwind = UNWIND_HIGH32 (&call_info->ci_unwind.descriptor);
6078   md_number_to_chars (p + 12, unwind, 4);
6079
6080   /* Return back to the original segment/subsegment.  */
6081   subseg_set (save_seg, save_subseg);
6082 }
6083 #endif
6084
6085 /* Process a .CALLINFO pseudo-op.  This information is used later
6086    to build unwind descriptors and maybe one day to support
6087    .ENTER and .LEAVE.  */
6088
6089 static void
6090 pa_callinfo (int unused ATTRIBUTE_UNUSED)
6091 {
6092   char *name, c, *p;
6093   int temp;
6094
6095 #ifdef OBJ_SOM
6096   /* We must have a valid space and subspace.  */
6097   pa_check_current_space_and_subspace ();
6098 #endif
6099
6100   /* .CALLINFO must appear within a procedure definition.  */
6101   if (!within_procedure)
6102     as_bad (_(".callinfo is not within a procedure definition"));
6103
6104   /* Mark the fact that we found the .CALLINFO for the
6105      current procedure.  */
6106   callinfo_found = TRUE;
6107
6108   /* Iterate over the .CALLINFO arguments.  */
6109   while (!is_end_of_statement ())
6110     {
6111       name = input_line_pointer;
6112       c = get_symbol_end ();
6113       /* Frame size specification.  */
6114       if ((strncasecmp (name, "frame", 5) == 0))
6115         {
6116           p = input_line_pointer;
6117           *p = c;
6118           input_line_pointer++;
6119           temp = get_absolute_expression ();
6120           if ((temp & 0x3) != 0)
6121             {
6122               as_bad (_("FRAME parameter must be a multiple of 8: %d\n"), temp);
6123               temp = 0;
6124             }
6125
6126           /* callinfo is in bytes and unwind_desc is in 8 byte units.  */
6127           last_call_info->ci_unwind.descriptor.frame_size = temp / 8;
6128
6129         }
6130       /* Entry register (GR, GR and SR) specifications.  */
6131       else if ((strncasecmp (name, "entry_gr", 8) == 0))
6132         {
6133           p = input_line_pointer;
6134           *p = c;
6135           input_line_pointer++;
6136           temp = get_absolute_expression ();
6137           /* The HP assembler accepts 19 as the high bound for ENTRY_GR
6138              even though %r19 is caller saved.  I think this is a bug in
6139              the HP assembler, and we are not going to emulate it.  */
6140           if (temp < 3 || temp > 18)
6141             as_bad (_("Value for ENTRY_GR must be in the range 3..18\n"));
6142           last_call_info->ci_unwind.descriptor.entry_gr = temp - 2;
6143         }
6144       else if ((strncasecmp (name, "entry_fr", 8) == 0))
6145         {
6146           p = input_line_pointer;
6147           *p = c;
6148           input_line_pointer++;
6149           temp = get_absolute_expression ();
6150           /* Similarly the HP assembler takes 31 as the high bound even
6151              though %fr21 is the last callee saved floating point register.  */
6152           if (temp < 12 || temp > 21)
6153             as_bad (_("Value for ENTRY_FR must be in the range 12..21\n"));
6154           last_call_info->ci_unwind.descriptor.entry_fr = temp - 11;
6155         }
6156       else if ((strncasecmp (name, "entry_sr", 8) == 0))
6157         {
6158           p = input_line_pointer;
6159           *p = c;
6160           input_line_pointer++;
6161           temp = get_absolute_expression ();
6162           if (temp != 3)
6163             as_bad (_("Value for ENTRY_SR must be 3\n"));
6164         }
6165       /* Note whether or not this function performs any calls.  */
6166       else if ((strncasecmp (name, "calls", 5) == 0) ||
6167                (strncasecmp (name, "caller", 6) == 0))
6168         {
6169           p = input_line_pointer;
6170           *p = c;
6171         }
6172       else if ((strncasecmp (name, "no_calls", 8) == 0))
6173         {
6174           p = input_line_pointer;
6175           *p = c;
6176         }
6177       /* Should RP be saved into the stack.  */
6178       else if ((strncasecmp (name, "save_rp", 7) == 0))
6179         {
6180           p = input_line_pointer;
6181           *p = c;
6182           last_call_info->ci_unwind.descriptor.save_rp = 1;
6183         }
6184       /* Likewise for SP.  */
6185       else if ((strncasecmp (name, "save_sp", 7) == 0))
6186         {
6187           p = input_line_pointer;
6188           *p = c;
6189           last_call_info->ci_unwind.descriptor.save_sp = 1;
6190         }
6191       /* Is this an unwindable procedure.  If so mark it so
6192          in the unwind descriptor.  */
6193       else if ((strncasecmp (name, "no_unwind", 9) == 0))
6194         {
6195           p = input_line_pointer;
6196           *p = c;
6197           last_call_info->ci_unwind.descriptor.cannot_unwind = 1;
6198         }
6199       /* Is this an interrupt routine.  If so mark it in the
6200          unwind descriptor.  */
6201       else if ((strncasecmp (name, "hpux_int", 7) == 0))
6202         {
6203           p = input_line_pointer;
6204           *p = c;
6205           last_call_info->ci_unwind.descriptor.hpux_interrupt_marker = 1;
6206         }
6207       /* Is this a millicode routine.  "millicode" isn't in my
6208          assembler manual, but my copy is old.  The HP assembler
6209          accepts it, and there's a place in the unwind descriptor
6210          to drop the information, so we'll accept it too.  */
6211       else if ((strncasecmp (name, "millicode", 9) == 0))
6212         {
6213           p = input_line_pointer;
6214           *p = c;
6215           last_call_info->ci_unwind.descriptor.millicode = 1;
6216         }
6217       else
6218         {
6219           as_bad (_("Invalid .CALLINFO argument: %s"), name);
6220           *input_line_pointer = c;
6221         }
6222       if (!is_end_of_statement ())
6223         input_line_pointer++;
6224     }
6225
6226   demand_empty_rest_of_line ();
6227 }
6228
6229 #if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
6230 /* Switch to the text space.  Like s_text, but delete our
6231    label when finished.  */
6232
6233 static void
6234 pa_text (int unused ATTRIBUTE_UNUSED)
6235 {
6236 #ifdef OBJ_SOM
6237   current_space = is_defined_space ("$TEXT$");
6238   current_subspace
6239     = pa_subsegment_to_subspace (current_space->sd_seg, 0);
6240 #endif
6241
6242   s_text (0);
6243   pa_undefine_label ();
6244 }
6245
6246 /* Switch to the data space.  As usual delete our label.  */
6247
6248 static void
6249 pa_data (int unused ATTRIBUTE_UNUSED)
6250 {
6251 #ifdef OBJ_SOM
6252   current_space = is_defined_space ("$PRIVATE$");
6253   current_subspace
6254     = pa_subsegment_to_subspace (current_space->sd_seg, 0);
6255 #endif
6256   s_data (0);
6257   pa_undefine_label ();
6258 }
6259
6260 /* This is different than the standard GAS s_comm(). On HP9000/800 machines,
6261    the .comm pseudo-op has the following syntax:
6262
6263    <label> .comm <length>
6264
6265    where <label> is optional and is a symbol whose address will be the start of
6266    a block of memory <length> bytes long. <length> must be an absolute
6267    expression.  <length> bytes will be allocated in the current space
6268    and subspace.
6269
6270    Also note the label may not even be on the same line as the .comm.
6271
6272    This difference in syntax means the colon function will be called
6273    on the symbol before we arrive in pa_comm.  colon will set a number
6274    of attributes of the symbol that need to be fixed here.  In particular
6275    the value, section pointer, fragment pointer, flags, etc.  What
6276    a pain.
6277
6278    This also makes error detection all but impossible.  */
6279
6280 static void
6281 pa_comm (int unused ATTRIBUTE_UNUSED)
6282 {
6283   unsigned int size;
6284   symbolS *symbol;
6285   label_symbol_struct *label_symbol = pa_get_label ();
6286
6287   if (label_symbol)
6288     symbol = label_symbol->lss_label;
6289   else
6290     symbol = NULL;
6291
6292   SKIP_WHITESPACE ();
6293   size = get_absolute_expression ();
6294
6295   if (symbol)
6296     {
6297       symbol_get_bfdsym (symbol)->flags |= BSF_OBJECT;
6298       S_SET_VALUE (symbol, size);
6299       S_SET_SEGMENT (symbol, bfd_com_section_ptr);
6300       S_SET_EXTERNAL (symbol);
6301
6302       /* colon() has already set the frag to the current location in the
6303          current subspace; we need to reset the fragment to the zero address
6304          fragment.  We also need to reset the segment pointer.  */
6305       symbol_set_frag (symbol, &zero_address_frag);
6306     }
6307   demand_empty_rest_of_line ();
6308 }
6309 #endif /* !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD))) */
6310
6311 /* Process a .END pseudo-op.  */
6312
6313 static void
6314 pa_end (int unused ATTRIBUTE_UNUSED)
6315 {
6316   demand_empty_rest_of_line ();
6317 }
6318
6319 /* Process a .ENTER pseudo-op.  This is not supported.  */
6320
6321 static void
6322 pa_enter (int unused ATTRIBUTE_UNUSED)
6323 {
6324 #ifdef OBJ_SOM
6325   /* We must have a valid space and subspace.  */
6326   pa_check_current_space_and_subspace ();
6327 #endif
6328
6329   as_bad (_("The .ENTER pseudo-op is not supported"));
6330   demand_empty_rest_of_line ();
6331 }
6332
6333 /* Process a .ENTRY pseudo-op.  .ENTRY marks the beginning of the
6334    procedure.  */
6335
6336 static void
6337 pa_entry (int unused ATTRIBUTE_UNUSED)
6338 {
6339 #ifdef OBJ_SOM
6340   /* We must have a valid space and subspace.  */
6341   pa_check_current_space_and_subspace ();
6342 #endif
6343
6344   if (!within_procedure)
6345     as_bad (_("Misplaced .entry. Ignored."));
6346   else
6347     {
6348       if (!callinfo_found)
6349         as_bad (_("Missing .callinfo."));
6350     }
6351   demand_empty_rest_of_line ();
6352   within_entry_exit = TRUE;
6353
6354 #ifdef OBJ_SOM
6355   /* SOM defers building of unwind descriptors until the link phase.
6356      The assembler is responsible for creating an R_ENTRY relocation
6357      to mark the beginning of a region and hold the unwind bits, and
6358      for creating an R_EXIT relocation to mark the end of the region.
6359
6360      FIXME.  ELF should be using the same conventions!  The problem
6361      is an unwind requires too much relocation space.  Hmmm.  Maybe
6362      if we split the unwind bits up between the relocations which
6363      denote the entry and exit points.  */
6364   if (last_call_info->start_symbol != NULL)
6365     {
6366       char *where;
6367       unsigned int u;
6368
6369       where = frag_more (0);
6370       u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
6371       fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6372                     NULL, (offsetT) 0, NULL,
6373                     0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
6374     }
6375 #endif
6376 }
6377
6378 /* Silly nonsense for pa_equ.  The only half-sensible use for this is
6379    being able to subtract two register symbols that specify a range of
6380    registers, to get the size of the range.  */
6381 static int fudge_reg_expressions;
6382
6383 int
6384 hppa_force_reg_syms_absolute (expressionS *resultP,
6385                               operatorT op ATTRIBUTE_UNUSED,
6386                               expressionS *rightP)
6387 {
6388   if (fudge_reg_expressions
6389       && rightP->X_op == O_register
6390       && resultP->X_op == O_register)
6391     {
6392       rightP->X_op = O_constant;
6393       resultP->X_op = O_constant;
6394     }
6395   return 0;  /* Continue normal expr handling.  */
6396 }
6397
6398 /* Handle a .EQU pseudo-op.  */
6399
6400 static void
6401 pa_equ (int reg)
6402 {
6403   label_symbol_struct *label_symbol = pa_get_label ();
6404   symbolS *symbol;
6405
6406   if (label_symbol)
6407     {
6408       symbol = label_symbol->lss_label;
6409       if (reg)
6410         {
6411           strict = 1;
6412           if (!pa_parse_number (&input_line_pointer, 0))
6413             as_bad (_(".REG expression must be a register"));
6414           S_SET_VALUE (symbol, pa_number);
6415           S_SET_SEGMENT (symbol, reg_section);
6416         }
6417       else
6418         {
6419           expressionS exp;
6420           segT seg;
6421
6422           fudge_reg_expressions = 1;
6423           seg = expression (&exp);
6424           fudge_reg_expressions = 0;
6425           if (exp.X_op != O_constant
6426               && exp.X_op != O_register)
6427             {
6428               if (exp.X_op != O_absent)
6429                 as_bad (_("bad or irreducible absolute expression; zero assumed"));
6430               exp.X_add_number = 0;
6431               seg = absolute_section;
6432             }
6433           S_SET_VALUE (symbol, (unsigned int) exp.X_add_number);
6434           S_SET_SEGMENT (symbol, seg);
6435         }
6436     }
6437   else
6438     {
6439       if (reg)
6440         as_bad (_(".REG must use a label"));
6441       else
6442         as_bad (_(".EQU must use a label"));
6443     }
6444
6445   pa_undefine_label ();
6446   demand_empty_rest_of_line ();
6447 }
6448
6449 #ifdef OBJ_ELF
6450 /* Mark the end of a function so that it's possible to compute
6451    the size of the function in elf_hppa_final_processing.  */
6452
6453 static void
6454 hppa_elf_mark_end_of_function (void)
6455 {
6456   /* ELF does not have EXIT relocations.  All we do is create a
6457      temporary symbol marking the end of the function.  */
6458   char *name;
6459
6460   if (last_call_info == NULL || last_call_info->start_symbol == NULL)
6461     {
6462       /* We have already warned about a missing label,
6463          or other problems.  */
6464       return;
6465     }
6466
6467   name = xmalloc (strlen ("L$\001end_")
6468                   + strlen (S_GET_NAME (last_call_info->start_symbol))
6469                   + 1);
6470   if (name)
6471     {
6472       symbolS *symbolP;
6473
6474       strcpy (name, "L$\001end_");
6475       strcat (name, S_GET_NAME (last_call_info->start_symbol));
6476
6477       /* If we have a .exit followed by a .procend, then the
6478          symbol will have already been defined.  */
6479       symbolP = symbol_find (name);
6480       if (symbolP)
6481         {
6482           /* The symbol has already been defined!  This can
6483              happen if we have a .exit followed by a .procend.
6484
6485              This is *not* an error.  All we want to do is free
6486              the memory we just allocated for the name and continue.  */
6487           xfree (name);
6488         }
6489       else
6490         {
6491           /* symbol value should be the offset of the
6492              last instruction of the function */
6493           symbolP = symbol_new (name, now_seg, (valueT) (frag_now_fix () - 4),
6494                                 frag_now);
6495
6496           gas_assert (symbolP);
6497           S_CLEAR_EXTERNAL (symbolP);
6498           symbol_table_insert (symbolP);
6499         }
6500
6501       if (symbolP)
6502         last_call_info->end_symbol = symbolP;
6503       else
6504         as_bad (_("Symbol '%s' could not be created."), name);
6505
6506     }
6507   else
6508     as_bad (_("No memory for symbol name."));
6509 }
6510 #endif
6511
6512 /* Helper function.  Does processing for the end of a function.  This
6513    usually involves creating some relocations or building special
6514    symbols to mark the end of the function.  */
6515
6516 static void
6517 process_exit (void)
6518 {
6519   char *where;
6520
6521   where = frag_more (0);
6522
6523 #ifdef OBJ_ELF
6524   /* Mark the end of the function, stuff away the location of the frag
6525      for the end of the function, and finally call pa_build_unwind_subspace
6526      to add an entry in the unwind table.  */
6527   (void) where;
6528   hppa_elf_mark_end_of_function ();
6529   pa_build_unwind_subspace (last_call_info);
6530 #else
6531   /* SOM defers building of unwind descriptors until the link phase.
6532      The assembler is responsible for creating an R_ENTRY relocation
6533      to mark the beginning of a region and hold the unwind bits, and
6534      for creating an R_EXIT relocation to mark the end of the region.
6535
6536      FIXME.  ELF should be using the same conventions!  The problem
6537      is an unwind requires too much relocation space.  Hmmm.  Maybe
6538      if we split the unwind bits up between the relocations which
6539      denote the entry and exit points.  */
6540   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6541                 NULL, (offsetT) 0,
6542                 NULL, 0, R_HPPA_EXIT, e_fsel, 0, 0,
6543                 UNWIND_HIGH32 (&last_call_info->ci_unwind.descriptor));
6544 #endif
6545 }
6546
6547 /* Process a .EXIT pseudo-op.  */
6548
6549 static void
6550 pa_exit (int unused ATTRIBUTE_UNUSED)
6551 {
6552 #ifdef OBJ_SOM
6553   /* We must have a valid space and subspace.  */
6554   pa_check_current_space_and_subspace ();
6555 #endif
6556
6557   if (!within_procedure)
6558     as_bad (_(".EXIT must appear within a procedure"));
6559   else
6560     {
6561       if (!callinfo_found)
6562         as_bad (_("Missing .callinfo"));
6563       else
6564         {
6565           if (!within_entry_exit)
6566             as_bad (_("No .ENTRY for this .EXIT"));
6567           else
6568             {
6569               within_entry_exit = FALSE;
6570               process_exit ();
6571             }
6572         }
6573     }
6574   demand_empty_rest_of_line ();
6575 }
6576
6577 /* Helper function to process arguments to a .EXPORT pseudo-op.  */
6578
6579 static void
6580 pa_type_args (symbolS *symbolP, int is_export)
6581 {
6582   char *name, c, *p;
6583   unsigned int temp, arg_reloc;
6584   pa_symbol_type type = SYMBOL_TYPE_UNKNOWN;
6585   asymbol *bfdsym = symbol_get_bfdsym (symbolP);
6586
6587   if (strncasecmp (input_line_pointer, "absolute", 8) == 0)
6588     {
6589       input_line_pointer += 8;
6590       bfdsym->flags &= ~BSF_FUNCTION;
6591       S_SET_SEGMENT (symbolP, bfd_abs_section_ptr);
6592       type = SYMBOL_TYPE_ABSOLUTE;
6593     }
6594   else if (strncasecmp (input_line_pointer, "code", 4) == 0)
6595     {
6596       input_line_pointer += 4;
6597       /* IMPORTing/EXPORTing CODE types for functions is meaningless for SOM,
6598          instead one should be IMPORTing/EXPORTing ENTRY types.
6599
6600          Complain if one tries to EXPORT a CODE type since that's never
6601          done.  Both GCC and HP C still try to IMPORT CODE types, so
6602          silently fix them to be ENTRY types.  */
6603       if (S_IS_FUNCTION (symbolP))
6604         {
6605           if (is_export)
6606             as_tsktsk (_("Using ENTRY rather than CODE in export directive for %s"),
6607                        S_GET_NAME (symbolP));
6608
6609           bfdsym->flags |= BSF_FUNCTION;
6610           type = SYMBOL_TYPE_ENTRY;
6611         }
6612       else
6613         {
6614           bfdsym->flags &= ~BSF_FUNCTION;
6615           type = SYMBOL_TYPE_CODE;
6616         }
6617     }
6618   else if (strncasecmp (input_line_pointer, "data", 4) == 0)
6619     {
6620       input_line_pointer += 4;
6621       bfdsym->flags &= ~BSF_FUNCTION;
6622       bfdsym->flags |= BSF_OBJECT;
6623       type = SYMBOL_TYPE_DATA;
6624     }
6625   else if ((strncasecmp (input_line_pointer, "entry", 5) == 0))
6626     {
6627       input_line_pointer += 5;
6628       bfdsym->flags |= BSF_FUNCTION;
6629       type = SYMBOL_TYPE_ENTRY;
6630     }
6631   else if (strncasecmp (input_line_pointer, "millicode", 9) == 0)
6632     {
6633       input_line_pointer += 9;
6634       bfdsym->flags |= BSF_FUNCTION;
6635 #ifdef OBJ_ELF
6636       {
6637         elf_symbol_type *elfsym = (elf_symbol_type *) bfdsym;
6638         elfsym->internal_elf_sym.st_info =
6639           ELF_ST_INFO (ELF_ST_BIND (elfsym->internal_elf_sym.st_info),
6640                        STT_PARISC_MILLI);
6641       }
6642 #endif
6643       type = SYMBOL_TYPE_MILLICODE;
6644     }
6645   else if (strncasecmp (input_line_pointer, "plabel", 6) == 0)
6646     {
6647       input_line_pointer += 6;
6648       bfdsym->flags &= ~BSF_FUNCTION;
6649       type = SYMBOL_TYPE_PLABEL;
6650     }
6651   else if (strncasecmp (input_line_pointer, "pri_prog", 8) == 0)
6652     {
6653       input_line_pointer += 8;
6654       bfdsym->flags |= BSF_FUNCTION;
6655       type = SYMBOL_TYPE_PRI_PROG;
6656     }
6657   else if (strncasecmp (input_line_pointer, "sec_prog", 8) == 0)
6658     {
6659       input_line_pointer += 8;
6660       bfdsym->flags |= BSF_FUNCTION;
6661       type = SYMBOL_TYPE_SEC_PROG;
6662     }
6663
6664   /* SOM requires much more information about symbol types
6665      than BFD understands.  This is how we get this information
6666      to the SOM BFD backend.  */
6667 #ifdef obj_set_symbol_type
6668   obj_set_symbol_type (bfdsym, (int) type);
6669 #else
6670   (void) type;
6671 #endif
6672
6673   /* Now that the type of the exported symbol has been handled,
6674      handle any argument relocation information.  */
6675   while (!is_end_of_statement ())
6676     {
6677       if (*input_line_pointer == ',')
6678         input_line_pointer++;
6679       name = input_line_pointer;
6680       c = get_symbol_end ();
6681       /* Argument sources.  */
6682       if ((strncasecmp (name, "argw", 4) == 0))
6683         {
6684           p = input_line_pointer;
6685           *p = c;
6686           input_line_pointer++;
6687           temp = atoi (name + 4);
6688           name = input_line_pointer;
6689           c = get_symbol_end ();
6690           arg_reloc = pa_align_arg_reloc (temp, pa_build_arg_reloc (name));
6691 #if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
6692           symbol_arg_reloc_info (symbolP) |= arg_reloc;
6693 #else
6694           (void) arg_reloc;
6695 #endif
6696           *input_line_pointer = c;
6697         }
6698       /* The return value.  */
6699       else if ((strncasecmp (name, "rtnval", 6)) == 0)
6700         {
6701           p = input_line_pointer;
6702           *p = c;
6703           input_line_pointer++;
6704           name = input_line_pointer;
6705           c = get_symbol_end ();
6706           arg_reloc = pa_build_arg_reloc (name);
6707 #if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
6708           symbol_arg_reloc_info (symbolP) |= arg_reloc;
6709 #else
6710           (void) arg_reloc;
6711 #endif
6712           *input_line_pointer = c;
6713         }
6714       /* Privilege level.  */
6715       else if ((strncasecmp (name, "priv_lev", 8)) == 0)
6716         {
6717           p = input_line_pointer;
6718           *p = c;
6719           input_line_pointer++;
6720           temp = atoi (input_line_pointer);
6721 #ifdef OBJ_SOM
6722           ((obj_symbol_type *) bfdsym)->tc_data.ap.hppa_priv_level = temp;
6723 #endif
6724           c = get_symbol_end ();
6725           *input_line_pointer = c;
6726         }
6727       else
6728         {
6729           as_bad (_("Undefined .EXPORT/.IMPORT argument (ignored): %s"), name);
6730           p = input_line_pointer;
6731           *p = c;
6732         }
6733       if (!is_end_of_statement ())
6734         input_line_pointer++;
6735     }
6736 }
6737
6738 /* Process a .EXPORT directive.  This makes functions external
6739    and provides information such as argument relocation entries
6740    to callers.  */
6741
6742 static void
6743 pa_export (int unused ATTRIBUTE_UNUSED)
6744 {
6745   char *name, c, *p;
6746   symbolS *symbol;
6747
6748   name = input_line_pointer;
6749   c = get_symbol_end ();
6750   /* Make sure the given symbol exists.  */
6751   if ((symbol = symbol_find_or_make (name)) == NULL)
6752     {
6753       as_bad (_("Cannot define export symbol: %s\n"), name);
6754       p = input_line_pointer;
6755       *p = c;
6756       input_line_pointer++;
6757     }
6758   else
6759     {
6760       /* OK.  Set the external bits and process argument relocations.
6761          For the HP, weak and global are not mutually exclusive.
6762          S_SET_EXTERNAL will not set BSF_GLOBAL if WEAK is set.
6763          Call S_SET_EXTERNAL to get the other processing.  Manually
6764          set BSF_GLOBAL when we get back.  */
6765       S_SET_EXTERNAL (symbol);
6766       symbol_get_bfdsym (symbol)->flags |= BSF_GLOBAL;
6767       p = input_line_pointer;
6768       *p = c;
6769       if (!is_end_of_statement ())
6770         {
6771           input_line_pointer++;
6772           pa_type_args (symbol, 1);
6773         }
6774     }
6775
6776   demand_empty_rest_of_line ();
6777 }
6778
6779 /* Handle an .IMPORT pseudo-op.  Any symbol referenced in a given
6780    assembly file must either be defined in the assembly file, or
6781    explicitly IMPORTED from another.  */
6782
6783 static void
6784 pa_import (int unused ATTRIBUTE_UNUSED)
6785 {
6786   char *name, c, *p;
6787   symbolS *symbol;
6788
6789   name = input_line_pointer;
6790   c = get_symbol_end ();
6791
6792   symbol = symbol_find (name);
6793   /* Ugh.  We might be importing a symbol defined earlier in the file,
6794      in which case all the code below will really screw things up
6795      (set the wrong segment, symbol flags & type, etc).  */
6796   if (symbol == NULL || !S_IS_DEFINED (symbol))
6797     {
6798       symbol = symbol_find_or_make (name);
6799       p = input_line_pointer;
6800       *p = c;
6801
6802       if (!is_end_of_statement ())
6803         {
6804           input_line_pointer++;
6805           pa_type_args (symbol, 0);
6806         }
6807       else
6808         {
6809           /* Sigh.  To be compatible with the HP assembler and to help
6810              poorly written assembly code, we assign a type based on
6811              the current segment.  Note only BSF_FUNCTION really
6812              matters, we do not need to set the full SYMBOL_TYPE_* info.  */
6813           if (now_seg == text_section)
6814             symbol_get_bfdsym (symbol)->flags |= BSF_FUNCTION;
6815
6816           /* If the section is undefined, then the symbol is undefined
6817              Since this is an import, leave the section undefined.  */
6818           S_SET_SEGMENT (symbol, bfd_und_section_ptr);
6819         }
6820     }
6821   else
6822     {
6823       /* The symbol was already defined.  Just eat everything up to
6824          the end of the current statement.  */
6825       while (!is_end_of_statement ())
6826         input_line_pointer++;
6827     }
6828
6829   demand_empty_rest_of_line ();
6830 }
6831
6832 /* Handle a .LABEL pseudo-op.  */
6833
6834 static void
6835 pa_label (int unused ATTRIBUTE_UNUSED)
6836 {
6837   char *name, c, *p;
6838
6839   name = input_line_pointer;
6840   c = get_symbol_end ();
6841
6842   if (strlen (name) > 0)
6843     {
6844       colon (name);
6845       p = input_line_pointer;
6846       *p = c;
6847     }
6848   else
6849     {
6850       as_warn (_("Missing label name on .LABEL"));
6851     }
6852
6853   if (!is_end_of_statement ())
6854     {
6855       as_warn (_("extra .LABEL arguments ignored."));
6856       ignore_rest_of_line ();
6857     }
6858   demand_empty_rest_of_line ();
6859 }
6860
6861 /* Handle a .LEAVE pseudo-op.  This is not supported yet.  */
6862
6863 static void
6864 pa_leave (int unused ATTRIBUTE_UNUSED)
6865 {
6866 #ifdef OBJ_SOM
6867   /* We must have a valid space and subspace.  */
6868   pa_check_current_space_and_subspace ();
6869 #endif
6870
6871   as_bad (_("The .LEAVE pseudo-op is not supported"));
6872   demand_empty_rest_of_line ();
6873 }
6874
6875 /* Handle a .LEVEL pseudo-op.  */
6876
6877 static void
6878 pa_level (int unused ATTRIBUTE_UNUSED)
6879 {
6880   char *level;
6881
6882   level = input_line_pointer;
6883   if (strncmp (level, "1.0", 3) == 0)
6884     {
6885       input_line_pointer += 3;
6886       if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 10))
6887         as_warn (_("could not set architecture and machine"));
6888     }
6889   else if (strncmp (level, "1.1", 3) == 0)
6890     {
6891       input_line_pointer += 3;
6892       if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 11))
6893         as_warn (_("could not set architecture and machine"));
6894     }
6895   else if (strncmp (level, "2.0w", 4) == 0)
6896     {
6897       input_line_pointer += 4;
6898       if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 25))
6899         as_warn (_("could not set architecture and machine"));
6900     }
6901   else if (strncmp (level, "2.0", 3) == 0)
6902     {
6903       input_line_pointer += 3;
6904       if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 20))
6905         as_warn (_("could not set architecture and machine"));
6906     }
6907   else
6908     {
6909       as_bad (_("Unrecognized .LEVEL argument\n"));
6910       ignore_rest_of_line ();
6911     }
6912   demand_empty_rest_of_line ();
6913 }
6914
6915 /* Handle a .ORIGIN pseudo-op.  */
6916
6917 static void
6918 pa_origin (int unused ATTRIBUTE_UNUSED)
6919 {
6920 #ifdef OBJ_SOM
6921   /* We must have a valid space and subspace.  */
6922   pa_check_current_space_and_subspace ();
6923 #endif
6924
6925   s_org (0);
6926   pa_undefine_label ();
6927 }
6928
6929 /* Handle a .PARAM pseudo-op.  This is much like a .EXPORT, except it
6930    is for static functions.  FIXME.  Should share more code with .EXPORT.  */
6931
6932 static void
6933 pa_param (int unused ATTRIBUTE_UNUSED)
6934 {
6935   char *name, c, *p;
6936   symbolS *symbol;
6937
6938   name = input_line_pointer;
6939   c = get_symbol_end ();
6940
6941   if ((symbol = symbol_find_or_make (name)) == NULL)
6942     {
6943       as_bad (_("Cannot define static symbol: %s\n"), name);
6944       p = input_line_pointer;
6945       *p = c;
6946       input_line_pointer++;
6947     }
6948   else
6949     {
6950       S_CLEAR_EXTERNAL (symbol);
6951       p = input_line_pointer;
6952       *p = c;
6953       if (!is_end_of_statement ())
6954         {
6955           input_line_pointer++;
6956           pa_type_args (symbol, 0);
6957         }
6958     }
6959
6960   demand_empty_rest_of_line ();
6961 }
6962
6963 /* Handle a .PROC pseudo-op.  It is used to mark the beginning
6964    of a procedure from a syntactical point of view.  */
6965
6966 static void
6967 pa_proc (int unused ATTRIBUTE_UNUSED)
6968 {
6969   struct call_info *call_info;
6970
6971 #ifdef OBJ_SOM
6972   /* We must have a valid space and subspace.  */
6973   pa_check_current_space_and_subspace ();
6974 #endif
6975
6976   if (within_procedure)
6977     as_fatal (_("Nested procedures"));
6978
6979   /* Reset global variables for new procedure.  */
6980   callinfo_found = FALSE;
6981   within_procedure = TRUE;
6982
6983   /* Create another call_info structure.  */
6984   call_info = xmalloc (sizeof (struct call_info));
6985
6986   if (!call_info)
6987     as_fatal (_("Cannot allocate unwind descriptor\n"));
6988
6989   memset (call_info, 0, sizeof (struct call_info));
6990
6991   call_info->ci_next = NULL;
6992
6993   if (call_info_root == NULL)
6994     {
6995       call_info_root = call_info;
6996       last_call_info = call_info;
6997     }
6998   else
6999     {
7000       last_call_info->ci_next = call_info;
7001       last_call_info = call_info;
7002     }
7003
7004   /* set up defaults on call_info structure */
7005
7006   call_info->ci_unwind.descriptor.cannot_unwind = 0;
7007   call_info->ci_unwind.descriptor.region_desc = 1;
7008   call_info->ci_unwind.descriptor.hpux_interrupt_marker = 0;
7009
7010   /* If we got a .PROC pseudo-op, we know that the function is defined
7011      locally.  Make sure it gets into the symbol table.  */
7012   {
7013     label_symbol_struct *label_symbol = pa_get_label ();
7014
7015     if (label_symbol)
7016       {
7017         if (label_symbol->lss_label)
7018           {
7019             last_call_info->start_symbol = label_symbol->lss_label;
7020             symbol_get_bfdsym (label_symbol->lss_label)->flags |= BSF_FUNCTION;
7021           }
7022         else
7023           as_bad (_("Missing function name for .PROC (corrupted label chain)"));
7024       }
7025     else
7026       last_call_info->start_symbol = NULL;
7027   }
7028
7029   demand_empty_rest_of_line ();
7030 }
7031
7032 /* Process the syntactical end of a procedure.  Make sure all the
7033    appropriate pseudo-ops were found within the procedure.  */
7034
7035 static void
7036 pa_procend (int unused ATTRIBUTE_UNUSED)
7037 {
7038 #ifdef OBJ_SOM
7039   /* We must have a valid space and subspace.  */
7040   pa_check_current_space_and_subspace ();
7041 #endif
7042
7043   /* If we are within a procedure definition, make sure we've
7044      defined a label for the procedure; handle case where the
7045      label was defined after the .PROC directive.
7046
7047      Note there's not need to diddle with the segment or fragment
7048      for the label symbol in this case.  We have already switched
7049      into the new $CODE$ subspace at this point.  */
7050   if (within_procedure && last_call_info->start_symbol == NULL)
7051     {
7052       label_symbol_struct *label_symbol = pa_get_label ();
7053
7054       if (label_symbol)
7055         {
7056           if (label_symbol->lss_label)
7057             {
7058               last_call_info->start_symbol = label_symbol->lss_label;
7059               symbol_get_bfdsym (label_symbol->lss_label)->flags
7060                 |= BSF_FUNCTION;
7061 #ifdef OBJ_SOM
7062               /* Also handle allocation of a fixup to hold the unwind
7063                  information when the label appears after the proc/procend.  */
7064               if (within_entry_exit)
7065                 {
7066                   char *where;
7067                   unsigned int u;
7068
7069                   where = frag_more (0);
7070                   u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
7071                   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
7072                                 NULL, (offsetT) 0, NULL,
7073                                 0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
7074                 }
7075 #endif
7076             }
7077           else
7078             as_bad (_("Missing function name for .PROC (corrupted label chain)"));
7079         }
7080       else
7081         as_bad (_("Missing function name for .PROC"));
7082     }
7083
7084   if (!within_procedure)
7085     as_bad (_("misplaced .procend"));
7086
7087   if (!callinfo_found)
7088     as_bad (_("Missing .callinfo for this procedure"));
7089
7090   if (within_entry_exit)
7091     as_bad (_("Missing .EXIT for a .ENTRY"));
7092
7093 #ifdef OBJ_ELF
7094   /* ELF needs to mark the end of each function so that it can compute
7095      the size of the function (apparently its needed in the symbol table).  */
7096   hppa_elf_mark_end_of_function ();
7097 #endif
7098
7099   within_procedure = FALSE;
7100   demand_empty_rest_of_line ();
7101   pa_undefine_label ();
7102 }
7103
7104 #ifdef OBJ_SOM
7105 /* If VALUE is an exact power of two between zero and 2^31, then
7106    return log2 (VALUE).  Else return -1.  */
7107
7108 static int
7109 exact_log2 (int value)
7110 {
7111   int shift = 0;
7112
7113   while ((1 << shift) != value && shift < 32)
7114     shift++;
7115
7116   if (shift >= 32)
7117     return -1;
7118   else
7119     return shift;
7120 }
7121
7122 /* Check to make sure we have a valid space and subspace.  */
7123
7124 static void
7125 pa_check_current_space_and_subspace (void)
7126 {
7127   if (current_space == NULL)
7128     as_fatal (_("Not in a space.\n"));
7129
7130   if (current_subspace == NULL)
7131     as_fatal (_("Not in a subspace.\n"));
7132 }
7133
7134 /* Parse the parameters to a .SPACE directive; if CREATE_FLAG is nonzero,
7135    then create a new space entry to hold the information specified
7136    by the parameters to the .SPACE directive.  */
7137
7138 static sd_chain_struct *
7139 pa_parse_space_stmt (char *space_name, int create_flag)
7140 {
7141   char *name, *ptemp, c;
7142   char loadable, defined, private, sort;
7143   int spnum;
7144   asection *seg = NULL;
7145   sd_chain_struct *space;
7146
7147   /* Load default values.  */
7148   spnum = 0;
7149   sort = 0;
7150   loadable = TRUE;
7151   defined = TRUE;
7152   private = FALSE;
7153   if (strcmp (space_name, "$TEXT$") == 0)
7154     {
7155       seg = pa_def_spaces[0].segment;
7156       defined = pa_def_spaces[0].defined;
7157       private = pa_def_spaces[0].private;
7158       sort = pa_def_spaces[0].sort;
7159       spnum = pa_def_spaces[0].spnum;
7160     }
7161   else if (strcmp (space_name, "$PRIVATE$") == 0)
7162     {
7163       seg = pa_def_spaces[1].segment;
7164       defined = pa_def_spaces[1].defined;
7165       private = pa_def_spaces[1].private;
7166       sort = pa_def_spaces[1].sort;
7167       spnum = pa_def_spaces[1].spnum;
7168     }
7169
7170   if (!is_end_of_statement ())
7171     {
7172       print_errors = FALSE;
7173       ptemp = input_line_pointer + 1;
7174       /* First see if the space was specified as a number rather than
7175          as a name.  According to the PA assembly manual the rest of
7176          the line should be ignored.  */
7177       strict = 0;
7178       pa_parse_number (&ptemp, 0);
7179       if (pa_number >= 0)
7180         {
7181           spnum = pa_number;
7182           input_line_pointer = ptemp;
7183         }
7184       else
7185         {
7186           while (!is_end_of_statement ())
7187             {
7188               input_line_pointer++;
7189               name = input_line_pointer;
7190               c = get_symbol_end ();
7191               if ((strncasecmp (name, "spnum", 5) == 0))
7192                 {
7193                   *input_line_pointer = c;
7194                   input_line_pointer++;
7195                   spnum = get_absolute_expression ();
7196                 }
7197               else if ((strncasecmp (name, "sort", 4) == 0))
7198                 {
7199                   *input_line_pointer = c;
7200                   input_line_pointer++;
7201                   sort = get_absolute_expression ();
7202                 }
7203               else if ((strncasecmp (name, "unloadable", 10) == 0))
7204                 {
7205                   *input_line_pointer = c;
7206                   loadable = FALSE;
7207                 }
7208               else if ((strncasecmp (name, "notdefined", 10) == 0))
7209                 {
7210                   *input_line_pointer = c;
7211                   defined = FALSE;
7212                 }
7213               else if ((strncasecmp (name, "private", 7) == 0))
7214                 {
7215                   *input_line_pointer = c;
7216                   private = TRUE;
7217                 }
7218               else
7219                 {
7220                   as_bad (_("Invalid .SPACE argument"));
7221                   *input_line_pointer = c;
7222                   if (!is_end_of_statement ())
7223                     input_line_pointer++;
7224                 }
7225             }
7226         }
7227       print_errors = TRUE;
7228     }
7229
7230   if (create_flag && seg == NULL)
7231     seg = subseg_new (space_name, 0);
7232
7233   /* If create_flag is nonzero, then create the new space with
7234      the attributes computed above.  Else set the values in
7235      an already existing space -- this can only happen for
7236      the first occurrence of a built-in space.  */
7237   if (create_flag)
7238     space = create_new_space (space_name, spnum, loadable, defined,
7239                               private, sort, seg, 1);
7240   else
7241     {
7242       space = is_defined_space (space_name);
7243       SPACE_SPNUM (space) = spnum;
7244       SPACE_DEFINED (space) = defined & 1;
7245       SPACE_USER_DEFINED (space) = 1;
7246     }
7247
7248 #ifdef obj_set_section_attributes
7249   obj_set_section_attributes (seg, defined, private, sort, spnum);
7250 #endif
7251
7252   return space;
7253 }
7254
7255 /* Handle a .SPACE pseudo-op; this switches the current space to the
7256    given space, creating the new space if necessary.  */
7257
7258 static void
7259 pa_space (int unused ATTRIBUTE_UNUSED)
7260 {
7261   char *name, c, *space_name, *save_s;
7262   sd_chain_struct *sd_chain;
7263
7264   if (within_procedure)
7265     {
7266       as_bad (_("Can\'t change spaces within a procedure definition. Ignored"));
7267       ignore_rest_of_line ();
7268     }
7269   else
7270     {
7271       /* Check for some of the predefined spaces.   FIXME: most of the code
7272          below is repeated several times, can we extract the common parts
7273          and place them into a subroutine or something similar?  */
7274       /* FIXME Is this (and the next IF stmt) really right?
7275          What if INPUT_LINE_POINTER points to "$TEXT$FOO"?  */
7276       if (strncmp (input_line_pointer, "$TEXT$", 6) == 0)
7277         {
7278           input_line_pointer += 6;
7279           sd_chain = is_defined_space ("$TEXT$");
7280           if (sd_chain == NULL)
7281             sd_chain = pa_parse_space_stmt ("$TEXT$", 1);
7282           else if (SPACE_USER_DEFINED (sd_chain) == 0)
7283             sd_chain = pa_parse_space_stmt ("$TEXT$", 0);
7284
7285           current_space = sd_chain;
7286           subseg_set (text_section, sd_chain->sd_last_subseg);
7287           current_subspace
7288             = pa_subsegment_to_subspace (text_section,
7289                                          sd_chain->sd_last_subseg);
7290           demand_empty_rest_of_line ();
7291           return;
7292         }
7293       if (strncmp (input_line_pointer, "$PRIVATE$", 9) == 0)
7294         {
7295           input_line_pointer += 9;
7296           sd_chain = is_defined_space ("$PRIVATE$");
7297           if (sd_chain == NULL)
7298             sd_chain = pa_parse_space_stmt ("$PRIVATE$", 1);
7299           else if (SPACE_USER_DEFINED (sd_chain) == 0)
7300             sd_chain = pa_parse_space_stmt ("$PRIVATE$", 0);
7301
7302           current_space = sd_chain;
7303           subseg_set (data_section, sd_chain->sd_last_subseg);
7304           current_subspace
7305             = pa_subsegment_to_subspace (data_section,
7306                                          sd_chain->sd_last_subseg);
7307           demand_empty_rest_of_line ();
7308           return;
7309         }
7310       if (!strncasecmp (input_line_pointer,
7311                         GDB_DEBUG_SPACE_NAME,
7312                         strlen (GDB_DEBUG_SPACE_NAME)))
7313         {
7314           input_line_pointer += strlen (GDB_DEBUG_SPACE_NAME);
7315           sd_chain = is_defined_space (GDB_DEBUG_SPACE_NAME);
7316           if (sd_chain == NULL)
7317             sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 1);
7318           else if (SPACE_USER_DEFINED (sd_chain) == 0)
7319             sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 0);
7320
7321           current_space = sd_chain;
7322
7323           {
7324             asection *gdb_section
7325             = bfd_make_section_old_way (stdoutput, GDB_DEBUG_SPACE_NAME);
7326
7327             subseg_set (gdb_section, sd_chain->sd_last_subseg);
7328             current_subspace
7329               = pa_subsegment_to_subspace (gdb_section,
7330                                            sd_chain->sd_last_subseg);
7331           }
7332           demand_empty_rest_of_line ();
7333           return;
7334         }
7335
7336       /* It could be a space specified by number.  */
7337       print_errors = 0;
7338       save_s = input_line_pointer;
7339       strict = 0;
7340       pa_parse_number (&input_line_pointer, 0);
7341       if (pa_number >= 0)
7342         {
7343           if ((sd_chain = pa_find_space_by_number (pa_number)))
7344             {
7345               current_space = sd_chain;
7346
7347               subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
7348               current_subspace
7349                 = pa_subsegment_to_subspace (sd_chain->sd_seg,
7350                                              sd_chain->sd_last_subseg);
7351               demand_empty_rest_of_line ();
7352               return;
7353             }
7354         }
7355
7356       /* Not a number, attempt to create a new space.  */
7357       print_errors = 1;
7358       input_line_pointer = save_s;
7359       name = input_line_pointer;
7360       c = get_symbol_end ();
7361       space_name = xmalloc (strlen (name) + 1);
7362       strcpy (space_name, name);
7363       *input_line_pointer = c;
7364
7365       sd_chain = pa_parse_space_stmt (space_name, 1);
7366       current_space = sd_chain;
7367
7368       subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
7369       current_subspace = pa_subsegment_to_subspace (sd_chain->sd_seg,
7370                                                   sd_chain->sd_last_subseg);
7371       demand_empty_rest_of_line ();
7372     }
7373 }
7374
7375 /* Switch to a new space.  (I think).  FIXME.  */
7376
7377 static void
7378 pa_spnum (int unused ATTRIBUTE_UNUSED)
7379 {
7380   char *name;
7381   char c;
7382   char *p;
7383   sd_chain_struct *space;
7384
7385   name = input_line_pointer;
7386   c = get_symbol_end ();
7387   space = is_defined_space (name);
7388   if (space)
7389     {
7390       p = frag_more (4);
7391       md_number_to_chars (p, SPACE_SPNUM (space), 4);
7392     }
7393   else
7394     as_warn (_("Undefined space: '%s' Assuming space number = 0."), name);
7395
7396   *input_line_pointer = c;
7397   demand_empty_rest_of_line ();
7398 }
7399
7400 /* Handle a .SUBSPACE pseudo-op; this switches the current subspace to the
7401    given subspace, creating the new subspace if necessary.
7402
7403    FIXME.  Should mirror pa_space more closely, in particular how
7404    they're broken up into subroutines.  */
7405
7406 static void
7407 pa_subspace (int create_new)
7408 {
7409   char *name, *ss_name, c;
7410   char loadable, code_only, comdat, common, dup_common, zero, sort;
7411   int i, access_ctr, space_index, alignment, quadrant, applicable, flags;
7412   sd_chain_struct *space;
7413   ssd_chain_struct *ssd;
7414   asection *section;
7415
7416   if (current_space == NULL)
7417     as_fatal (_("Must be in a space before changing or declaring subspaces.\n"));
7418
7419   if (within_procedure)
7420     {
7421       as_bad (_("Can\'t change subspaces within a procedure definition. Ignored"));
7422       ignore_rest_of_line ();
7423     }
7424   else
7425     {
7426       name = input_line_pointer;
7427       c = get_symbol_end ();
7428       ss_name = xmalloc (strlen (name) + 1);
7429       strcpy (ss_name, name);
7430       *input_line_pointer = c;
7431
7432       /* Load default values.  */
7433       sort = 0;
7434       access_ctr = 0x7f;
7435       loadable = 1;
7436       comdat = 0;
7437       common = 0;
7438       dup_common = 0;
7439       code_only = 0;
7440       zero = 0;
7441       space_index = ~0;
7442       alignment = 1;
7443       quadrant = 0;
7444
7445       space = current_space;
7446       if (create_new)
7447         ssd = NULL;
7448       else
7449         ssd = is_defined_subspace (ss_name);
7450       /* Allow user to override the builtin attributes of subspaces.  But
7451          only allow the attributes to be changed once!  */
7452       if (ssd && SUBSPACE_DEFINED (ssd))
7453         {
7454           subseg_set (ssd->ssd_seg, ssd->ssd_subseg);
7455           current_subspace = ssd;
7456           if (!is_end_of_statement ())
7457             as_warn (_("Parameters of an existing subspace can\'t be modified"));
7458           demand_empty_rest_of_line ();
7459           return;
7460         }
7461       else
7462         {
7463           /* A new subspace.  Load default values if it matches one of
7464              the builtin subspaces.  */
7465           i = 0;
7466           while (pa_def_subspaces[i].name)
7467             {
7468               if (strcasecmp (pa_def_subspaces[i].name, ss_name) == 0)
7469                 {
7470                   loadable = pa_def_subspaces[i].loadable;
7471                   comdat = pa_def_subspaces[i].comdat;
7472                   common = pa_def_subspaces[i].common;
7473                   dup_common = pa_def_subspaces[i].dup_common;
7474                   code_only = pa_def_subspaces[i].code_only;
7475                   zero = pa_def_subspaces[i].zero;
7476                   space_index = pa_def_subspaces[i].space_index;
7477                   alignment = pa_def_subspaces[i].alignment;
7478                   quadrant = pa_def_subspaces[i].quadrant;
7479                   access_ctr = pa_def_subspaces[i].access;
7480                   sort = pa_def_subspaces[i].sort;
7481                   break;
7482                 }
7483               i++;
7484             }
7485         }
7486
7487       /* We should be working with a new subspace now.  Fill in
7488          any information as specified by the user.  */
7489       if (!is_end_of_statement ())
7490         {
7491           input_line_pointer++;
7492           while (!is_end_of_statement ())
7493             {
7494               name = input_line_pointer;
7495               c = get_symbol_end ();
7496               if ((strncasecmp (name, "quad", 4) == 0))
7497                 {
7498                   *input_line_pointer = c;
7499                   input_line_pointer++;
7500                   quadrant = get_absolute_expression ();
7501                 }
7502               else if ((strncasecmp (name, "align", 5) == 0))
7503                 {
7504                   *input_line_pointer = c;
7505                   input_line_pointer++;
7506                   alignment = get_absolute_expression ();
7507                   if (exact_log2 (alignment) == -1)
7508                     {
7509                       as_bad (_("Alignment must be a power of 2"));
7510                       alignment = 1;
7511                     }
7512                 }
7513               else if ((strncasecmp (name, "access", 6) == 0))
7514                 {
7515                   *input_line_pointer = c;
7516                   input_line_pointer++;
7517                   access_ctr = get_absolute_expression ();
7518                 }
7519               else if ((strncasecmp (name, "sort", 4) == 0))
7520                 {
7521                   *input_line_pointer = c;
7522                   input_line_pointer++;
7523                   sort = get_absolute_expression ();
7524                 }
7525               else if ((strncasecmp (name, "code_only", 9) == 0))
7526                 {
7527                   *input_line_pointer = c;
7528                   code_only = 1;
7529                 }
7530               else if ((strncasecmp (name, "unloadable", 10) == 0))
7531                 {
7532                   *input_line_pointer = c;
7533                   loadable = 0;
7534                 }
7535               else if ((strncasecmp (name, "comdat", 6) == 0))
7536                 {
7537                   *input_line_pointer = c;
7538                   comdat = 1;
7539                 }
7540               else if ((strncasecmp (name, "common", 6) == 0))
7541                 {
7542                   *input_line_pointer = c;
7543                   common = 1;
7544                 }
7545               else if ((strncasecmp (name, "dup_comm", 8) == 0))
7546                 {
7547                   *input_line_pointer = c;
7548                   dup_common = 1;
7549                 }
7550               else if ((strncasecmp (name, "zero", 4) == 0))
7551                 {
7552                   *input_line_pointer = c;
7553                   zero = 1;
7554                 }
7555               else if ((strncasecmp (name, "first", 5) == 0))
7556                 as_bad (_("FIRST not supported as a .SUBSPACE argument"));
7557               else
7558                 as_bad (_("Invalid .SUBSPACE argument"));
7559               if (!is_end_of_statement ())
7560                 input_line_pointer++;
7561             }
7562         }
7563
7564       /* Compute a reasonable set of BFD flags based on the information
7565          in the .subspace directive.  */
7566       applicable = bfd_applicable_section_flags (stdoutput);
7567       flags = 0;
7568       if (loadable)
7569         flags |= (SEC_ALLOC | SEC_LOAD);
7570       if (code_only)
7571         flags |= SEC_CODE;
7572
7573       /* These flags are used to implement various flavors of initialized
7574          common.  The SOM linker discards duplicate subspaces when they
7575          have the same "key" symbol name.  This support is more like
7576          GNU linkonce than BFD common.  Further, pc-relative relocations
7577          are converted to section relative relocations in BFD common
7578          sections.  This complicates the handling of relocations in
7579          common sections containing text and isn't currently supported
7580          correctly in the SOM BFD backend.  */
7581       if (comdat || common || dup_common)
7582         flags |= SEC_LINK_ONCE;
7583
7584       flags |= SEC_RELOC | SEC_HAS_CONTENTS;
7585
7586       /* This is a zero-filled subspace (eg BSS).  */
7587       if (zero)
7588         flags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
7589
7590       applicable &= flags;
7591
7592       /* If this is an existing subspace, then we want to use the
7593          segment already associated with the subspace.
7594
7595          FIXME NOW!  ELF BFD doesn't appear to be ready to deal with
7596          lots of sections.  It might be a problem in the PA ELF
7597          code, I do not know yet.  For now avoid creating anything
7598          but the "standard" sections for ELF.  */
7599       if (create_new)
7600         section = subseg_force_new (ss_name, 0);
7601       else if (ssd)
7602         section = ssd->ssd_seg;
7603       else
7604         section = subseg_new (ss_name, 0);
7605
7606       if (zero)
7607         seg_info (section)->bss = 1;
7608
7609       /* Now set the flags.  */
7610       bfd_set_section_flags (stdoutput, section, applicable);
7611
7612       /* Record any alignment request for this section.  */
7613       record_alignment (section, exact_log2 (alignment));
7614
7615       /* Set the starting offset for this section.  */
7616       bfd_set_section_vma (stdoutput, section,
7617                            pa_subspace_start (space, quadrant));
7618
7619       /* Now that all the flags are set, update an existing subspace,
7620          or create a new one.  */
7621       if (ssd)
7622
7623         current_subspace = update_subspace (space, ss_name, loadable,
7624                                             code_only, comdat, common,
7625                                             dup_common, sort, zero, access_ctr,
7626                                             space_index, alignment, quadrant,
7627                                             section);
7628       else
7629         current_subspace = create_new_subspace (space, ss_name, loadable,
7630                                                 code_only, comdat, common,
7631                                                 dup_common, zero, sort,
7632                                                 access_ctr, space_index,
7633                                                 alignment, quadrant, section);
7634
7635       demand_empty_rest_of_line ();
7636       current_subspace->ssd_seg = section;
7637       subseg_set (current_subspace->ssd_seg, current_subspace->ssd_subseg);
7638     }
7639   SUBSPACE_DEFINED (current_subspace) = 1;
7640 }
7641
7642 /* Create default space and subspace dictionaries.  */
7643
7644 static void
7645 pa_spaces_begin (void)
7646 {
7647   int i;
7648
7649   space_dict_root = NULL;
7650   space_dict_last = NULL;
7651
7652   i = 0;
7653   while (pa_def_spaces[i].name)
7654     {
7655       char *name;
7656
7657       /* Pick the right name to use for the new section.  */
7658       name = pa_def_spaces[i].name;
7659
7660       pa_def_spaces[i].segment = subseg_new (name, 0);
7661       create_new_space (pa_def_spaces[i].name, pa_def_spaces[i].spnum,
7662                         pa_def_spaces[i].loadable, pa_def_spaces[i].defined,
7663                         pa_def_spaces[i].private, pa_def_spaces[i].sort,
7664                         pa_def_spaces[i].segment, 0);
7665       i++;
7666     }
7667
7668   i = 0;
7669   while (pa_def_subspaces[i].name)
7670     {
7671       char *name;
7672       int applicable, subsegment;
7673       asection *segment = NULL;
7674       sd_chain_struct *space;
7675
7676       /* Pick the right name for the new section and pick the right
7677          subsegment number.  */
7678       name = pa_def_subspaces[i].name;
7679       subsegment = 0;
7680
7681       /* Create the new section.  */
7682       segment = subseg_new (name, subsegment);
7683
7684       /* For SOM we want to replace the standard .text, .data, and .bss
7685          sections with our own.   We also want to set BFD flags for
7686          all the built-in subspaces.  */
7687       if (!strcmp (pa_def_subspaces[i].name, "$CODE$"))
7688         {
7689           text_section = segment;
7690           applicable = bfd_applicable_section_flags (stdoutput);
7691           bfd_set_section_flags (stdoutput, segment,
7692                                  applicable & (SEC_ALLOC | SEC_LOAD
7693                                                | SEC_RELOC | SEC_CODE
7694                                                | SEC_READONLY
7695                                                | SEC_HAS_CONTENTS));
7696         }
7697       else if (!strcmp (pa_def_subspaces[i].name, "$DATA$"))
7698         {
7699           data_section = segment;
7700           applicable = bfd_applicable_section_flags (stdoutput);
7701           bfd_set_section_flags (stdoutput, segment,
7702                                  applicable & (SEC_ALLOC | SEC_LOAD
7703                                                | SEC_RELOC
7704                                                | SEC_HAS_CONTENTS));
7705
7706         }
7707       else if (!strcmp (pa_def_subspaces[i].name, "$BSS$"))
7708         {
7709           bss_section = segment;
7710           applicable = bfd_applicable_section_flags (stdoutput);
7711           bfd_set_section_flags (stdoutput, segment,
7712                                  applicable & SEC_ALLOC);
7713         }
7714       else if (!strcmp (pa_def_subspaces[i].name, "$LIT$"))
7715         {
7716           applicable = bfd_applicable_section_flags (stdoutput);
7717           bfd_set_section_flags (stdoutput, segment,
7718                                  applicable & (SEC_ALLOC | SEC_LOAD
7719                                                | SEC_RELOC
7720                                                | SEC_READONLY
7721                                                | SEC_HAS_CONTENTS));
7722         }
7723       else if (!strcmp (pa_def_subspaces[i].name, "$MILLICODE$"))
7724         {
7725           applicable = bfd_applicable_section_flags (stdoutput);
7726           bfd_set_section_flags (stdoutput, segment,
7727                                  applicable & (SEC_ALLOC | SEC_LOAD
7728                                                | SEC_RELOC
7729                                                | SEC_READONLY
7730                                                | SEC_HAS_CONTENTS));
7731         }
7732       else if (!strcmp (pa_def_subspaces[i].name, "$UNWIND$"))
7733         {
7734           applicable = bfd_applicable_section_flags (stdoutput);
7735           bfd_set_section_flags (stdoutput, segment,
7736                                  applicable & (SEC_ALLOC | SEC_LOAD
7737                                                | SEC_RELOC
7738                                                | SEC_READONLY
7739                                                | SEC_HAS_CONTENTS));
7740         }
7741
7742       /* Find the space associated with this subspace.  */
7743       space = pa_segment_to_space (pa_def_spaces[pa_def_subspaces[i].
7744                                                  def_space_index].segment);
7745       if (space == NULL)
7746         {
7747           as_fatal (_("Internal error: Unable to find containing space for %s."),
7748                     pa_def_subspaces[i].name);
7749         }
7750
7751       create_new_subspace (space, name,
7752                            pa_def_subspaces[i].loadable,
7753                            pa_def_subspaces[i].code_only,
7754                            pa_def_subspaces[i].comdat,
7755                            pa_def_subspaces[i].common,
7756                            pa_def_subspaces[i].dup_common,
7757                            pa_def_subspaces[i].zero,
7758                            pa_def_subspaces[i].sort,
7759                            pa_def_subspaces[i].access,
7760                            pa_def_subspaces[i].space_index,
7761                            pa_def_subspaces[i].alignment,
7762                            pa_def_subspaces[i].quadrant,
7763                            segment);
7764       i++;
7765     }
7766 }
7767
7768 /* Create a new space NAME, with the appropriate flags as defined
7769    by the given parameters.  */
7770
7771 static sd_chain_struct *
7772 create_new_space (char *name,
7773                   int spnum,
7774                   int loadable ATTRIBUTE_UNUSED,
7775                   int defined,
7776                   int private,
7777                   int sort,
7778                   asection *seg,
7779                   int user_defined)
7780 {
7781   sd_chain_struct *chain_entry;
7782
7783   chain_entry = xmalloc (sizeof (sd_chain_struct));
7784   if (!chain_entry)
7785     as_fatal (_("Out of memory: could not allocate new space chain entry: %s\n"),
7786               name);
7787
7788   SPACE_NAME (chain_entry) = xmalloc (strlen (name) + 1);
7789   strcpy (SPACE_NAME (chain_entry), name);
7790   SPACE_DEFINED (chain_entry) = defined;
7791   SPACE_USER_DEFINED (chain_entry) = user_defined;
7792   SPACE_SPNUM (chain_entry) = spnum;
7793
7794   chain_entry->sd_seg = seg;
7795   chain_entry->sd_last_subseg = -1;
7796   chain_entry->sd_subspaces = NULL;
7797   chain_entry->sd_next = NULL;
7798
7799   /* Find spot for the new space based on its sort key.  */
7800   if (!space_dict_last)
7801     space_dict_last = chain_entry;
7802
7803   if (space_dict_root == NULL)
7804     space_dict_root = chain_entry;
7805   else
7806     {
7807       sd_chain_struct *chain_pointer;
7808       sd_chain_struct *prev_chain_pointer;
7809
7810       chain_pointer = space_dict_root;
7811       prev_chain_pointer = NULL;
7812
7813       while (chain_pointer)
7814         {
7815           prev_chain_pointer = chain_pointer;
7816           chain_pointer = chain_pointer->sd_next;
7817         }
7818
7819       /* At this point we've found the correct place to add the new
7820          entry.  So add it and update the linked lists as appropriate.  */
7821       if (prev_chain_pointer)
7822         {
7823           chain_entry->sd_next = chain_pointer;
7824           prev_chain_pointer->sd_next = chain_entry;
7825         }
7826       else
7827         {
7828           space_dict_root = chain_entry;
7829           chain_entry->sd_next = chain_pointer;
7830         }
7831
7832       if (chain_entry->sd_next == NULL)
7833         space_dict_last = chain_entry;
7834     }
7835
7836   /* This is here to catch predefined spaces which do not get
7837      modified by the user's input.  Another call is found at
7838      the bottom of pa_parse_space_stmt to handle cases where
7839      the user modifies a predefined space.  */
7840 #ifdef obj_set_section_attributes
7841   obj_set_section_attributes (seg, defined, private, sort, spnum);
7842 #endif
7843
7844   return chain_entry;
7845 }
7846
7847 /* Create a new subspace NAME, with the appropriate flags as defined
7848    by the given parameters.
7849
7850    Add the new subspace to the subspace dictionary chain in numerical
7851    order as defined by the SORT entries.  */
7852
7853 static ssd_chain_struct *
7854 create_new_subspace (sd_chain_struct *space,
7855                      char *name,
7856                      int loadable ATTRIBUTE_UNUSED,
7857                      int code_only ATTRIBUTE_UNUSED,
7858                      int comdat,
7859                      int common,
7860                      int dup_common,
7861                      int is_zero ATTRIBUTE_UNUSED,
7862                      int sort,
7863                      int access_ctr,
7864                      int space_index ATTRIBUTE_UNUSED,
7865                      int alignment ATTRIBUTE_UNUSED,
7866                      int quadrant,
7867                      asection *seg)
7868 {
7869   ssd_chain_struct *chain_entry;
7870
7871   chain_entry = xmalloc (sizeof (ssd_chain_struct));
7872   if (!chain_entry)
7873     as_fatal (_("Out of memory: could not allocate new subspace chain entry: %s\n"), name);
7874
7875   SUBSPACE_NAME (chain_entry) = xmalloc (strlen (name) + 1);
7876   strcpy (SUBSPACE_NAME (chain_entry), name);
7877
7878   /* Initialize subspace_defined.  When we hit a .subspace directive
7879      we'll set it to 1 which "locks-in" the subspace attributes.  */
7880   SUBSPACE_DEFINED (chain_entry) = 0;
7881
7882   chain_entry->ssd_subseg = 0;
7883   chain_entry->ssd_seg = seg;
7884   chain_entry->ssd_next = NULL;
7885
7886   /* Find spot for the new subspace based on its sort key.  */
7887   if (space->sd_subspaces == NULL)
7888     space->sd_subspaces = chain_entry;
7889   else
7890     {
7891       ssd_chain_struct *chain_pointer;
7892       ssd_chain_struct *prev_chain_pointer;
7893
7894       chain_pointer = space->sd_subspaces;
7895       prev_chain_pointer = NULL;
7896
7897       while (chain_pointer)
7898         {
7899           prev_chain_pointer = chain_pointer;
7900           chain_pointer = chain_pointer->ssd_next;
7901         }
7902
7903       /* Now we have somewhere to put the new entry.  Insert it and update
7904          the links.  */
7905       if (prev_chain_pointer)
7906         {
7907           chain_entry->ssd_next = chain_pointer;
7908           prev_chain_pointer->ssd_next = chain_entry;
7909         }
7910       else
7911         {
7912           space->sd_subspaces = chain_entry;
7913           chain_entry->ssd_next = chain_pointer;
7914         }
7915     }
7916
7917 #ifdef obj_set_subsection_attributes
7918   obj_set_subsection_attributes (seg, space->sd_seg, access_ctr, sort,
7919                                  quadrant, comdat, common, dup_common);
7920 #endif
7921
7922   return chain_entry;
7923 }
7924
7925 /* Update the information for the given subspace based upon the
7926    various arguments.   Return the modified subspace chain entry.  */
7927
7928 static ssd_chain_struct *
7929 update_subspace (sd_chain_struct *space,
7930                  char *name,
7931                  int loadable ATTRIBUTE_UNUSED,
7932                  int code_only ATTRIBUTE_UNUSED,
7933                  int comdat,
7934                  int common,
7935                  int dup_common,
7936                  int sort,
7937                  int zero ATTRIBUTE_UNUSED,
7938                  int access_ctr,
7939                  int space_index ATTRIBUTE_UNUSED,
7940                  int alignment ATTRIBUTE_UNUSED,
7941                  int quadrant,
7942                  asection *section)
7943 {
7944   ssd_chain_struct *chain_entry;
7945
7946   chain_entry = is_defined_subspace (name);
7947
7948 #ifdef obj_set_subsection_attributes
7949   obj_set_subsection_attributes (section, space->sd_seg, access_ctr, sort,
7950                                  quadrant, comdat, common, dup_common);
7951 #endif
7952
7953   return chain_entry;
7954 }
7955
7956 /* Return the space chain entry for the space with the name NAME or
7957    NULL if no such space exists.  */
7958
7959 static sd_chain_struct *
7960 is_defined_space (char *name)
7961 {
7962   sd_chain_struct *chain_pointer;
7963
7964   for (chain_pointer = space_dict_root;
7965        chain_pointer;
7966        chain_pointer = chain_pointer->sd_next)
7967     if (strcmp (SPACE_NAME (chain_pointer), name) == 0)
7968       return chain_pointer;
7969
7970   /* No mapping from segment to space was found.  Return NULL.  */
7971   return NULL;
7972 }
7973
7974 /* Find and return the space associated with the given seg.  If no mapping
7975    from the given seg to a space is found, then return NULL.
7976
7977    Unlike subspaces, the number of spaces is not expected to grow much,
7978    so a linear exhaustive search is OK here.  */
7979
7980 static sd_chain_struct *
7981 pa_segment_to_space (asection *seg)
7982 {
7983   sd_chain_struct *space_chain;
7984
7985   /* Walk through each space looking for the correct mapping.  */
7986   for (space_chain = space_dict_root;
7987        space_chain;
7988        space_chain = space_chain->sd_next)
7989     if (space_chain->sd_seg == seg)
7990       return space_chain;
7991
7992   /* Mapping was not found.  Return NULL.  */
7993   return NULL;
7994 }
7995
7996 /* Return the first space chain entry for the subspace with the name
7997    NAME or NULL if no such subspace exists.
7998
7999    When there are multiple subspaces with the same name, switching to
8000    the first (i.e., default) subspace is preferable in most situations.
8001    For example, it wouldn't be desirable to merge COMDAT data with non
8002    COMDAT data.
8003
8004    Uses a linear search through all the spaces and subspaces, this may
8005    not be appropriate if we ever being placing each function in its
8006    own subspace.  */
8007
8008 static ssd_chain_struct *
8009 is_defined_subspace (char *name)
8010 {
8011   sd_chain_struct *space_chain;
8012   ssd_chain_struct *subspace_chain;
8013
8014   /* Walk through each space.  */
8015   for (space_chain = space_dict_root;
8016        space_chain;
8017        space_chain = space_chain->sd_next)
8018     {
8019       /* Walk through each subspace looking for a name which matches.  */
8020       for (subspace_chain = space_chain->sd_subspaces;
8021            subspace_chain;
8022            subspace_chain = subspace_chain->ssd_next)
8023         if (strcmp (SUBSPACE_NAME (subspace_chain), name) == 0)
8024           return subspace_chain;
8025     }
8026
8027   /* Subspace wasn't found.  Return NULL.  */
8028   return NULL;
8029 }
8030
8031 /* Find and return the subspace associated with the given seg.  If no
8032    mapping from the given seg to a subspace is found, then return NULL.
8033
8034    If we ever put each procedure/function within its own subspace
8035    (to make life easier on the compiler and linker), then this will have
8036    to become more efficient.  */
8037
8038 static ssd_chain_struct *
8039 pa_subsegment_to_subspace (asection *seg, subsegT subseg)
8040 {
8041   sd_chain_struct *space_chain;
8042   ssd_chain_struct *subspace_chain;
8043
8044   /* Walk through each space.  */
8045   for (space_chain = space_dict_root;
8046        space_chain;
8047        space_chain = space_chain->sd_next)
8048     {
8049       if (space_chain->sd_seg == seg)
8050         {
8051           /* Walk through each subspace within each space looking for
8052              the correct mapping.  */
8053           for (subspace_chain = space_chain->sd_subspaces;
8054                subspace_chain;
8055                subspace_chain = subspace_chain->ssd_next)
8056             if (subspace_chain->ssd_subseg == (int) subseg)
8057               return subspace_chain;
8058         }
8059     }
8060
8061   /* No mapping from subsegment to subspace found.  Return NULL.  */
8062   return NULL;
8063 }
8064
8065 /* Given a number, try and find a space with the name number.
8066
8067    Return a pointer to a space dictionary chain entry for the space
8068    that was found or NULL on failure.  */
8069
8070 static sd_chain_struct *
8071 pa_find_space_by_number (int number)
8072 {
8073   sd_chain_struct *space_chain;
8074
8075   for (space_chain = space_dict_root;
8076        space_chain;
8077        space_chain = space_chain->sd_next)
8078     {
8079       if (SPACE_SPNUM (space_chain) == (unsigned int) number)
8080         return space_chain;
8081     }
8082
8083   /* No appropriate space found.  Return NULL.  */
8084   return NULL;
8085 }
8086
8087 /* Return the starting address for the given subspace.  If the starting
8088    address is unknown then return zero.  */
8089
8090 static unsigned int
8091 pa_subspace_start (sd_chain_struct *space, int quadrant)
8092 {
8093   /* FIXME.  Assumes everyone puts read/write data at 0x4000000, this
8094      is not correct for the PA OSF1 port.  */
8095   if ((strcmp (SPACE_NAME (space), "$PRIVATE$") == 0) && quadrant == 1)
8096     return 0x40000000;
8097   else if (space->sd_seg == data_section && quadrant == 1)
8098     return 0x40000000;
8099   else
8100     return 0;
8101   return 0;
8102 }
8103 #endif
8104
8105 /* Helper function for pa_stringer.  Used to find the end of
8106    a string.  */
8107
8108 static unsigned int
8109 pa_stringer_aux (char *s)
8110 {
8111   unsigned int c = *s & CHAR_MASK;
8112
8113   switch (c)
8114     {
8115     case '\"':
8116       c = NOT_A_CHAR;
8117       break;
8118     default:
8119       break;
8120     }
8121   return c;
8122 }
8123
8124 /* Handle a .STRING type pseudo-op.  */
8125
8126 static void
8127 pa_stringer (int append_zero)
8128 {
8129   char *s, num_buf[4];
8130   unsigned int c;
8131   int i;
8132
8133   /* Preprocess the string to handle PA-specific escape sequences.
8134      For example, \xDD where DD is a hexadecimal number should be
8135      changed to \OOO where OOO is an octal number.  */
8136
8137 #ifdef OBJ_SOM
8138   /* We must have a valid space and subspace.  */
8139   pa_check_current_space_and_subspace ();
8140 #endif
8141
8142   /* Skip the opening quote.  */
8143   s = input_line_pointer + 1;
8144
8145   while (is_a_char (c = pa_stringer_aux (s++)))
8146     {
8147       if (c == '\\')
8148         {
8149           c = *s;
8150           switch (c)
8151             {
8152               /* Handle \x<num>.  */
8153             case 'x':
8154               {
8155                 unsigned int number;
8156                 int num_digit;
8157                 char dg;
8158                 char *s_start = s;
8159
8160                 /* Get past the 'x'.  */
8161                 s++;
8162                 for (num_digit = 0, number = 0, dg = *s;
8163                      num_digit < 2
8164                      && (ISDIGIT (dg) || (dg >= 'a' && dg <= 'f')
8165                          || (dg >= 'A' && dg <= 'F'));
8166                      num_digit++)
8167                   {
8168                     if (ISDIGIT (dg))
8169                       number = number * 16 + dg - '0';
8170                     else if (dg >= 'a' && dg <= 'f')
8171                       number = number * 16 + dg - 'a' + 10;
8172                     else
8173                       number = number * 16 + dg - 'A' + 10;
8174
8175                     s++;
8176                     dg = *s;
8177                   }
8178                 if (num_digit > 0)
8179                   {
8180                     switch (num_digit)
8181                       {
8182                       case 1:
8183                         sprintf (num_buf, "%02o", number);
8184                         break;
8185                       case 2:
8186                         sprintf (num_buf, "%03o", number);
8187                         break;
8188                       }
8189                     for (i = 0; i <= num_digit; i++)
8190                       s_start[i] = num_buf[i];
8191                   }
8192                 break;
8193               }
8194             /* This might be a "\"", skip over the escaped char.  */
8195             default:
8196               s++;
8197               break;
8198             }
8199         }
8200     }
8201   stringer (8 + append_zero);
8202   pa_undefine_label ();
8203 }
8204
8205 /* Handle a .VERSION pseudo-op.  */
8206
8207 static void
8208 pa_version (int unused ATTRIBUTE_UNUSED)
8209 {
8210   obj_version (0);
8211   pa_undefine_label ();
8212 }
8213
8214 #ifdef OBJ_SOM
8215
8216 /* Handle a .COMPILER pseudo-op.  */
8217
8218 static void
8219 pa_compiler (int unused ATTRIBUTE_UNUSED)
8220 {
8221   obj_som_compiler (0);
8222   pa_undefine_label ();
8223 }
8224
8225 #endif
8226
8227 /* Handle a .COPYRIGHT pseudo-op.  */
8228
8229 static void
8230 pa_copyright (int unused ATTRIBUTE_UNUSED)
8231 {
8232   obj_copyright (0);
8233   pa_undefine_label ();
8234 }
8235
8236 /* Just like a normal cons, but when finished we have to undefine
8237    the latest space label.  */
8238
8239 static void
8240 pa_cons (int nbytes)
8241 {
8242   cons (nbytes);
8243   pa_undefine_label ();
8244 }
8245
8246 /* Like float_cons, but we need to undefine our label.  */
8247
8248 static void
8249 pa_float_cons (int float_type)
8250 {
8251   float_cons (float_type);
8252   pa_undefine_label ();
8253 }
8254
8255 /* Like s_fill, but delete our label when finished.  */
8256
8257 static void
8258 pa_fill (int unused ATTRIBUTE_UNUSED)
8259 {
8260 #ifdef OBJ_SOM
8261   /* We must have a valid space and subspace.  */
8262   pa_check_current_space_and_subspace ();
8263 #endif
8264
8265   s_fill (0);
8266   pa_undefine_label ();
8267 }
8268
8269 /* Like lcomm, but delete our label when finished.  */
8270
8271 static void
8272 pa_lcomm (int needs_align)
8273 {
8274 #ifdef OBJ_SOM
8275   /* We must have a valid space and subspace.  */
8276   pa_check_current_space_and_subspace ();
8277 #endif
8278
8279   s_lcomm (needs_align);
8280   pa_undefine_label ();
8281 }
8282
8283 /* Like lsym, but delete our label when finished.  */
8284
8285 static void
8286 pa_lsym (int unused ATTRIBUTE_UNUSED)
8287 {
8288 #ifdef OBJ_SOM
8289   /* We must have a valid space and subspace.  */
8290   pa_check_current_space_and_subspace ();
8291 #endif
8292
8293   s_lsym (0);
8294   pa_undefine_label ();
8295 }
8296
8297 /* This function is called once, at assembler startup time.  It should
8298    set up all the tables, etc. that the MD part of the assembler will need.  */
8299
8300 void
8301 md_begin (void)
8302 {
8303   const char *retval = NULL;
8304   int lose = 0;
8305   unsigned int i = 0;
8306
8307   last_call_info = NULL;
8308   call_info_root = NULL;
8309
8310   /* Set the default machine type.  */
8311   if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, DEFAULT_LEVEL))
8312     as_warn (_("could not set architecture and machine"));
8313
8314   /* Folding of text and data segments fails miserably on the PA.
8315      Warn user and disable "-R" option.  */
8316   if (flag_readonly_data_in_text)
8317     {
8318       as_warn (_("-R option not supported on this target."));
8319       flag_readonly_data_in_text = 0;
8320     }
8321
8322 #ifdef OBJ_SOM
8323   pa_spaces_begin ();
8324 #endif
8325
8326   op_hash = hash_new ();
8327
8328   while (i < NUMOPCODES)
8329     {
8330       const char *name = pa_opcodes[i].name;
8331
8332       retval = hash_insert (op_hash, name, (struct pa_opcode *) &pa_opcodes[i]);
8333       if (retval != NULL && *retval != '\0')
8334         {
8335           as_fatal (_("Internal error: can't hash `%s': %s\n"), name, retval);
8336           lose = 1;
8337         }
8338
8339       do
8340         {
8341           if ((pa_opcodes[i].match & pa_opcodes[i].mask)
8342               != pa_opcodes[i].match)
8343             {
8344               fprintf (stderr, _("internal error: losing opcode: `%s' \"%s\"\n"),
8345                        pa_opcodes[i].name, pa_opcodes[i].args);
8346               lose = 1;
8347             }
8348           ++i;
8349         }
8350       while (i < NUMOPCODES && !strcmp (pa_opcodes[i].name, name));
8351     }
8352
8353   if (lose)
8354     as_fatal (_("Broken assembler.  No assembly attempted."));
8355
8356 #ifdef OBJ_SOM
8357   /* SOM will change text_section.  To make sure we never put
8358      anything into the old one switch to the new one now.  */
8359   subseg_set (text_section, 0);
8360 #endif
8361
8362 #ifdef OBJ_SOM
8363   dummy_symbol = symbol_find_or_make ("L$dummy");
8364   S_SET_SEGMENT (dummy_symbol, text_section);
8365   /* Force the symbol to be converted to a real symbol.  */
8366   symbol_get_bfdsym (dummy_symbol)->flags |= BSF_KEEP;
8367 #endif
8368 }
8369
8370 /* On the PA relocations which involve function symbols must not be
8371    adjusted.  This so that the linker can know when/how to create argument
8372    relocation stubs for indirect calls and calls to static functions.
8373
8374    "T" field selectors create DLT relative fixups for accessing
8375    globals and statics in PIC code; each DLT relative fixup creates
8376    an entry in the DLT table.  The entries contain the address of
8377    the final target (eg accessing "foo" would create a DLT entry
8378    with the address of "foo").
8379
8380    Unfortunately, the HP linker doesn't take into account any addend
8381    when generating the DLT; so accessing $LIT$+8 puts the address of
8382    $LIT$ into the DLT rather than the address of $LIT$+8.
8383
8384    The end result is we can't perform relocation symbol reductions for
8385    any fixup which creates entries in the DLT (eg they use "T" field
8386    selectors).
8387
8388    ??? Reject reductions involving symbols with external scope; such
8389    reductions make life a living hell for object file editors.  */
8390
8391 int
8392 hppa_fix_adjustable (fixS *fixp)
8393 {
8394 #ifdef OBJ_ELF
8395   reloc_type code;
8396 #endif
8397   struct hppa_fix_struct *hppa_fix;
8398
8399   hppa_fix = (struct hppa_fix_struct *) fixp->tc_fix_data;
8400
8401 #ifdef OBJ_ELF
8402   /* LR/RR selectors are implicitly used for a number of different relocation
8403      types.  We must ensure that none of these types are adjusted (see below)
8404      even if they occur with a different selector.  */
8405   code = elf_hppa_reloc_final_type (stdoutput, fixp->fx_r_type,
8406                                     hppa_fix->fx_r_format,
8407                                     hppa_fix->fx_r_field);
8408
8409   switch (code)
8410     {
8411     /* Relocation types which use e_lrsel.  */
8412     case R_PARISC_DIR21L:
8413     case R_PARISC_DLTREL21L:
8414     case R_PARISC_DPREL21L:
8415     case R_PARISC_PLTOFF21L:
8416
8417     /* Relocation types which use e_rrsel.  */
8418     case R_PARISC_DIR14R:
8419     case R_PARISC_DIR14DR:
8420     case R_PARISC_DIR14WR:
8421     case R_PARISC_DIR17R:
8422     case R_PARISC_DLTREL14R:
8423     case R_PARISC_DLTREL14DR:
8424     case R_PARISC_DLTREL14WR:
8425     case R_PARISC_DPREL14R:
8426     case R_PARISC_DPREL14DR:
8427     case R_PARISC_DPREL14WR:
8428     case R_PARISC_PLTOFF14R:
8429     case R_PARISC_PLTOFF14DR:
8430     case R_PARISC_PLTOFF14WR:
8431
8432     /* Other types that we reject for reduction.  */
8433     case R_PARISC_GNU_VTENTRY:
8434     case R_PARISC_GNU_VTINHERIT:
8435       return 0;
8436     default:
8437       break;
8438     }
8439 #endif
8440
8441   /* Reject reductions of symbols in sym1-sym2 expressions when
8442      the fixup will occur in a CODE subspace.
8443
8444      XXX FIXME: Long term we probably want to reject all of these;
8445      for example reducing in the debug section would lose if we ever
8446      supported using the optimizing hp linker.  */
8447   if (fixp->fx_addsy
8448       && fixp->fx_subsy
8449       && (hppa_fix->segment->flags & SEC_CODE))
8450     return 0;
8451
8452   /* We can't adjust any relocs that use LR% and RR% field selectors.
8453
8454      If a symbol is reduced to a section symbol, the assembler will
8455      adjust the addend unless the symbol happens to reside right at
8456      the start of the section.  Additionally, the linker has no choice
8457      but to manipulate the addends when coalescing input sections for
8458      "ld -r".  Since an LR% field selector is defined to round the
8459      addend, we can't change the addend without risking that a LR% and
8460      it's corresponding (possible multiple) RR% field will no longer
8461      sum to the right value.
8462
8463      eg. Suppose we have
8464      .          ldil    LR%foo+0,%r21
8465      .          ldw     RR%foo+0(%r21),%r26
8466      .          ldw     RR%foo+4(%r21),%r25
8467
8468      If foo is at address 4092 (decimal) in section `sect', then after
8469      reducing to the section symbol we get
8470      .                  LR%sect+4092 == (L%sect)+0
8471      .                  RR%sect+4092 == (R%sect)+4092
8472      .                  RR%sect+4096 == (R%sect)-4096
8473      and the last address loses because rounding the addend to 8k
8474      multiples takes us up to 8192 with an offset of -4096.
8475
8476      In cases where the LR% expression is identical to the RR% one we
8477      will never have a problem, but is so happens that gcc rounds
8478      addends involved in LR% field selectors to work around a HP
8479      linker bug.  ie. We often have addresses like the last case
8480      above where the LR% expression is offset from the RR% one.  */
8481
8482   if (hppa_fix->fx_r_field == e_lrsel
8483       || hppa_fix->fx_r_field == e_rrsel
8484       || hppa_fix->fx_r_field == e_nlrsel)
8485     return 0;
8486
8487   /* Reject reductions of symbols in DLT relative relocs,
8488      relocations with plabels.  */
8489   if (hppa_fix->fx_r_field == e_tsel
8490       || hppa_fix->fx_r_field == e_ltsel
8491       || hppa_fix->fx_r_field == e_rtsel
8492       || hppa_fix->fx_r_field == e_psel
8493       || hppa_fix->fx_r_field == e_rpsel
8494       || hppa_fix->fx_r_field == e_lpsel)
8495     return 0;
8496
8497   /* Reject absolute calls (jumps).  */
8498   if (hppa_fix->fx_r_type == R_HPPA_ABS_CALL)
8499     return 0;
8500
8501   /* Reject reductions of function symbols.  */
8502   if (fixp->fx_addsy != 0 && S_IS_FUNCTION (fixp->fx_addsy))
8503     return 0;
8504
8505   return 1;
8506 }
8507
8508 /* Return nonzero if the fixup in FIXP will require a relocation,
8509    even it if appears that the fixup could be completely handled
8510    within GAS.  */
8511
8512 int
8513 hppa_force_relocation (struct fix *fixp)
8514 {
8515   struct hppa_fix_struct *hppa_fixp;
8516
8517   hppa_fixp = (struct hppa_fix_struct *) fixp->tc_fix_data;
8518 #ifdef OBJ_SOM
8519   if (fixp->fx_r_type == (int) R_HPPA_ENTRY
8520       || fixp->fx_r_type == (int) R_HPPA_EXIT
8521       || fixp->fx_r_type == (int) R_HPPA_BEGIN_BRTAB
8522       || fixp->fx_r_type == (int) R_HPPA_END_BRTAB
8523       || fixp->fx_r_type == (int) R_HPPA_BEGIN_TRY
8524       || fixp->fx_r_type == (int) R_HPPA_END_TRY
8525       || (fixp->fx_addsy != NULL && fixp->fx_subsy != NULL
8526           && (hppa_fixp->segment->flags & SEC_CODE) != 0))
8527     return 1;
8528 #endif
8529 #ifdef OBJ_ELF
8530   if (fixp->fx_r_type == (int) R_PARISC_GNU_VTINHERIT
8531       || fixp->fx_r_type == (int) R_PARISC_GNU_VTENTRY)
8532     return 1;
8533 #endif
8534
8535   gas_assert (fixp->fx_addsy != NULL);
8536
8537   /* Ensure we emit a relocation for global symbols so that dynamic
8538      linking works.  */
8539   if (S_FORCE_RELOC (fixp->fx_addsy, 1))
8540     return 1;
8541
8542   /* It is necessary to force PC-relative calls/jumps to have a relocation
8543      entry if they're going to need either an argument relocation or long
8544      call stub.  */
8545   if (fixp->fx_pcrel
8546       && arg_reloc_stub_needed (symbol_arg_reloc_info (fixp->fx_addsy),
8547                                 hppa_fixp->fx_arg_reloc))
8548     return 1;
8549
8550   /* Now check to see if we're going to need a long-branch stub.  */
8551   if (fixp->fx_r_type == (int) R_HPPA_PCREL_CALL)
8552     {
8553       long pc = md_pcrel_from (fixp);
8554       valueT distance, min_stub_distance;
8555
8556       distance = fixp->fx_offset + S_GET_VALUE (fixp->fx_addsy) - pc - 8;
8557
8558       /* Distance to the closest possible stub.  This will detect most
8559          but not all circumstances where a stub will not work.  */
8560       min_stub_distance = pc + 16;
8561 #ifdef OBJ_SOM
8562       if (last_call_info != NULL)
8563         min_stub_distance -= S_GET_VALUE (last_call_info->start_symbol);
8564 #endif
8565
8566       if ((distance + 8388608 >= 16777216
8567            && min_stub_distance <= 8388608)
8568           || (hppa_fixp->fx_r_format == 17
8569               && distance + 262144 >= 524288
8570               && min_stub_distance <= 262144)
8571           || (hppa_fixp->fx_r_format == 12
8572               && distance + 8192 >= 16384
8573               && min_stub_distance <= 8192)
8574           )
8575         return 1;
8576     }
8577
8578   if (fixp->fx_r_type == (int) R_HPPA_ABS_CALL)
8579     return 1;
8580
8581   /* No need (yet) to force another relocations to be emitted.  */
8582   return 0;
8583 }
8584
8585 /* Now for some ELF specific code.  FIXME.  */
8586 #ifdef OBJ_ELF
8587 /* For ELF, this function serves one purpose:  to setup the st_size
8588    field of STT_FUNC symbols.  To do this, we need to scan the
8589    call_info structure list, determining st_size in by taking the
8590    difference in the address of the beginning/end marker symbols.  */
8591
8592 void
8593 elf_hppa_final_processing (void)
8594 {
8595   struct call_info *call_info_pointer;
8596
8597   for (call_info_pointer = call_info_root;
8598        call_info_pointer;
8599        call_info_pointer = call_info_pointer->ci_next)
8600     {
8601       elf_symbol_type *esym
8602         = ((elf_symbol_type *)
8603            symbol_get_bfdsym (call_info_pointer->start_symbol));
8604       esym->internal_elf_sym.st_size =
8605         S_GET_VALUE (call_info_pointer->end_symbol)
8606         - S_GET_VALUE (call_info_pointer->start_symbol) + 4;
8607     }
8608 }
8609
8610 static void
8611 pa_vtable_entry (int ignore ATTRIBUTE_UNUSED)
8612 {
8613   struct fix *new_fix;
8614
8615   new_fix = obj_elf_vtable_entry (0);
8616
8617   if (new_fix)
8618     {
8619       struct hppa_fix_struct * hppa_fix = obstack_alloc (&notes, sizeof (struct hppa_fix_struct));
8620
8621       hppa_fix->fx_r_type = R_HPPA;
8622       hppa_fix->fx_r_field = e_fsel;
8623       hppa_fix->fx_r_format = 32;
8624       hppa_fix->fx_arg_reloc = 0;
8625       hppa_fix->segment = now_seg;
8626       new_fix->tc_fix_data = (void *) hppa_fix;
8627       new_fix->fx_r_type = (int) R_PARISC_GNU_VTENTRY;
8628     }
8629 }
8630
8631 static void
8632 pa_vtable_inherit (int ignore ATTRIBUTE_UNUSED)
8633 {
8634   struct fix *new_fix;
8635
8636   new_fix = obj_elf_vtable_inherit (0);
8637
8638   if (new_fix)
8639     {
8640       struct hppa_fix_struct * hppa_fix = obstack_alloc (&notes, sizeof (struct hppa_fix_struct));
8641
8642       hppa_fix->fx_r_type = R_HPPA;
8643       hppa_fix->fx_r_field = e_fsel;
8644       hppa_fix->fx_r_format = 32;
8645       hppa_fix->fx_arg_reloc = 0;
8646       hppa_fix->segment = now_seg;
8647       new_fix->tc_fix_data = (void *) hppa_fix;
8648       new_fix->fx_r_type = (int) R_PARISC_GNU_VTINHERIT;
8649     }
8650 }
8651 #endif
8652
8653 /* Table of pseudo ops for the PA.  FIXME -- how many of these
8654    are now redundant with the overall GAS and the object file
8655    dependent tables?  */
8656 const pseudo_typeS md_pseudo_table[] =
8657 {
8658   /* align pseudo-ops on the PA specify the actual alignment requested,
8659      not the log2 of the requested alignment.  */
8660 #ifdef OBJ_SOM
8661   {"align", pa_align, 8},
8662 #endif
8663 #ifdef OBJ_ELF
8664   {"align", s_align_bytes, 8},
8665 #endif
8666   {"begin_brtab", pa_brtab, 1},
8667   {"begin_try", pa_try, 1},
8668   {"block", pa_block, 1},
8669   {"blockz", pa_block, 0},
8670   {"byte", pa_cons, 1},
8671   {"call", pa_call, 0},
8672   {"callinfo", pa_callinfo, 0},
8673 #if defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD))
8674   {"code", obj_elf_text, 0},
8675 #else
8676   {"code", pa_text, 0},
8677   {"comm", pa_comm, 0},
8678 #endif
8679 #ifdef OBJ_SOM
8680   {"compiler", pa_compiler, 0},
8681 #endif
8682   {"copyright", pa_copyright, 0},
8683 #if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
8684   {"data", pa_data, 0},
8685 #endif
8686   {"double", pa_float_cons, 'd'},
8687   {"dword", pa_cons, 8},
8688   {"end", pa_end, 0},
8689   {"end_brtab", pa_brtab, 0},
8690 #if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
8691   {"end_try", pa_try, 0},
8692 #endif
8693   {"enter", pa_enter, 0},
8694   {"entry", pa_entry, 0},
8695   {"equ", pa_equ, 0},
8696   {"exit", pa_exit, 0},
8697   {"export", pa_export, 0},
8698   {"fill", pa_fill, 0},
8699   {"float", pa_float_cons, 'f'},
8700   {"half", pa_cons, 2},
8701   {"import", pa_import, 0},
8702   {"int", pa_cons, 4},
8703   {"label", pa_label, 0},
8704   {"lcomm", pa_lcomm, 0},
8705   {"leave", pa_leave, 0},
8706   {"level", pa_level, 0},
8707   {"long", pa_cons, 4},
8708   {"lsym", pa_lsym, 0},
8709 #ifdef OBJ_SOM
8710   {"nsubspa", pa_subspace, 1},
8711 #endif
8712   {"octa", pa_cons, 16},
8713   {"org", pa_origin, 0},
8714   {"origin", pa_origin, 0},
8715   {"param", pa_param, 0},
8716   {"proc", pa_proc, 0},
8717   {"procend", pa_procend, 0},
8718   {"quad", pa_cons, 8},
8719   {"reg", pa_equ, 1},
8720   {"short", pa_cons, 2},
8721   {"single", pa_float_cons, 'f'},
8722 #ifdef OBJ_SOM
8723   {"space", pa_space, 0},
8724   {"spnum", pa_spnum, 0},
8725 #endif
8726   {"string", pa_stringer, 0},
8727   {"stringz", pa_stringer, 1},
8728 #ifdef OBJ_SOM
8729   {"subspa", pa_subspace, 0},
8730 #endif
8731 #if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
8732   {"text", pa_text, 0},
8733 #endif
8734   {"version", pa_version, 0},
8735 #ifdef OBJ_ELF
8736   {"vtable_entry", pa_vtable_entry, 0},
8737   {"vtable_inherit", pa_vtable_inherit, 0},
8738 #endif
8739   {"word", pa_cons, 4},
8740   {NULL, 0, 0}
8741 };
8742
8743 #ifdef OBJ_ELF
8744 void
8745 hppa_cfi_frame_initial_instructions (void)
8746 {
8747   cfi_add_CFA_def_cfa (30, 0);
8748 }
8749
8750 int
8751 hppa_regname_to_dw2regnum (char *regname)
8752 {
8753   unsigned int regnum = -1;
8754   unsigned int i;
8755   const char *p;
8756   char *q;
8757   static struct { char *name; int dw2regnum; } regnames[] =
8758     {
8759       { "sp", 30 }, { "rp", 2 },
8760     };
8761
8762   for (i = 0; i < ARRAY_SIZE (regnames); ++i)
8763     if (strcmp (regnames[i].name, regname) == 0)
8764       return regnames[i].dw2regnum;
8765
8766   if (regname[0] == 'r')
8767     {
8768       p = regname + 1;
8769       regnum = strtoul (p, &q, 10);
8770       if (p == q || *q || regnum >= 32)
8771         return -1;
8772     }
8773   else if (regname[0] == 'f' && regname[1] == 'r')
8774     {
8775       p = regname + 2;
8776       regnum = strtoul (p, &q, 10);
8777 #if TARGET_ARCH_SIZE == 64
8778       if (p == q || *q || regnum <= 4 || regnum >= 32)
8779         return -1;
8780       regnum += 32 - 4;
8781 #else
8782       if (p == q
8783           || (*q  && ((*q != 'L' && *q != 'R') || *(q + 1)))
8784           || regnum <= 4 || regnum >= 32)
8785         return -1;
8786       regnum = (regnum - 4) * 2 + 32;
8787       if (*q == 'R')
8788         regnum++;
8789 #endif
8790     }
8791   return regnum;
8792 }
8793 #endif