gas/config/tc-hppa.c

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