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     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     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     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     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     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 (char *, int, int,
 507                                                   int, int, int,
 508                                                   asection *, int);
 509 static ssd_chain_struct *create_new_subspace (sd_chain_struct *,
 510                                                       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 (char *);
 520 static ssd_chain_struct *is_defined_subspace (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 (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 = obstack_alloc (&notes, sizeof (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 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 = xmalloc (sizeof (arelent));
1359
1360   reloc->sym_ptr_ptr = xmalloc (sizeof (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 = xmalloc (sizeof (arelent *) * n_relocs + 1);
1392   reloc = xmalloc (sizeof (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 = xmalloc (sizeof (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 = xmalloc (sizeof (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 = xmalloc (sizeof (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 = xmalloc (sizeof (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 = xmalloc (sizeof (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 = xmalloc (sizeof (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, 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   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 if (*args == 'e')
3509                       {
3510                         /* Stash the ma/mb flag temporarily in the
3511                            instruction.  We will use (and remove it)
3512                            later when handling 'J', 'K', '<' & '>'.  */
3513                         opcode |= a;
3514                         continue;
3515                       }
3516                   }
3517
3518                 /* Handle a stbys completer.  */
3519                 case 'A':
3520                 case 's':
3521                   {
3522                     int a = 0;
3523                     int m = 0;
3524                     int i = 0;
3525                     while (*s == ',' && i < 2)
3526                       {
3527                         s++;
3528                         if (strncasecmp (s, "m", 1) == 0)
3529                           m = 1;
3530                         else if ((strncasecmp (s, "b ", 2) == 0)
3531                                  || (strncasecmp (s, "b,", 2) == 0))
3532                           a = 0;
3533                         else if (strncasecmp (s, "e", 1) == 0)
3534                           a = 1;
3535                         /* In strict mode, this is a match failure.  */
3536                         else if (strict)
3537                           {
3538                             s--;
3539                             break;
3540                           }
3541                         else
3542                           as_bad (_("Invalid Store Bytes Short Completer"));
3543                         s++;
3544                         i++;
3545                       }
3546                     if (i > 2)
3547                       as_bad (_("Invalid Store Bytes Short Completer"));
3548                     opcode |= m << 5;
3549                     INSERT_FIELD_AND_CONTINUE (opcode, a, 13);
3550                   }
3551
3552                 /* Handle load cache hint completer.  */
3553                 case 'c':
3554                   cmpltr = 0;
3555                   if (!strncmp (s, ",sl", 3))
3556                     {
3557                       s += 3;
3558                       cmpltr = 2;
3559                     }
3560                   INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 10);
3561
3562                 /* Handle store cache hint completer.  */
3563                 case 'C':
3564                   cmpltr = 0;
3565                   if (!strncmp (s, ",sl", 3))
3566                     {
3567                       s += 3;
3568                       cmpltr = 2;
3569                     }
3570                   else if (!strncmp (s, ",bc", 3))
3571                     {
3572                       s += 3;
3573                       cmpltr = 1;
3574                     }
3575                   INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 10);
3576
3577                 /* Handle load and clear cache hint completer.  */
3578                 case 'd':
3579                   cmpltr = 0;
3580                   if (!strncmp (s, ",co", 3))
3581                     {
3582                       s += 3;
3583                       cmpltr = 1;
3584                     }
3585                   INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 10);
3586
3587                 /* Handle load ordering completer.  */
3588                 case 'o':
3589                   if (strncmp (s, ",o", 2) != 0)
3590                     break;
3591                   s += 2;
3592                   continue;
3593
3594                 /* Handle a branch gate completer.  */
3595                 case 'g':
3596                   if (strncasecmp (s, ",gate", 5) != 0)
3597                     break;
3598                   s += 5;
3599                   continue;
3600
3601                 /* Handle a branch link and push completer.  */
3602                 case 'p':
3603                   if (strncasecmp (s, ",l,push", 7) != 0)
3604                     break;
3605                   s += 7;
3606                   continue;
3607
3608                 /* Handle a branch link completer.  */
3609                 case 'l':
3610                   if (strncasecmp (s, ",l", 2) != 0)
3611                     break;
3612                   s += 2;
3613                   continue;
3614
3615                 /* Handle a branch pop completer.  */
3616                 case 'P':
3617                   if (strncasecmp (s, ",pop", 4) != 0)
3618                     break;
3619                   s += 4;
3620                   continue;
3621
3622                 /* Handle a local processor completer.  */
3623                 case 'L':
3624                   if (strncasecmp (s, ",l", 2) != 0)
3625                     break;
3626                   s += 2;
3627                   continue;
3628
3629                 /* Handle a PROBE read/write completer.  */
3630                 case 'w':
3631                   flag = 0;
3632                   if (!strncasecmp (s, ",w", 2))
3633                     {
3634                       flag = 1;
3635                       s += 2;
3636                     }
3637                   else if (!strncasecmp (s, ",r", 2))
3638                     {
3639                       flag = 0;
3640                       s += 2;
3641                     }
3642
3643                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 6);
3644
3645                 /* Handle MFCTL wide completer.  */
3646                 case 'W':
3647                   if (strncasecmp (s, ",w", 2) != 0)
3648                     break;
3649                   s += 2;
3650                   continue;
3651
3652                 /* Handle an RFI restore completer.  */
3653                 case 'r':
3654                   flag = 0;
3655                   if (!strncasecmp (s, ",r", 2))
3656                     {
3657                       flag = 5;
3658                       s += 2;
3659                     }
3660
3661                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 5);
3662
3663                 /* Handle a system control completer.  */
3664                 case 'Z':
3665                   if (*s == ',' && (*(s + 1) == 'm' || *(s + 1) == 'M'))
3666                     {
3667                       flag = 1;
3668                       s += 2;
3669                     }
3670                   else
3671                     flag = 0;
3672
3673                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 5);
3674
3675                 /* Handle intermediate/final completer for DCOR.  */
3676                 case 'i':
3677                   flag = 0;
3678                   if (!strncasecmp (s, ",i", 2))
3679                     {
3680                       flag = 1;
3681                       s += 2;
3682                     }
3683
3684                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 6);
3685
3686                 /* Handle zero/sign extension completer.  */
3687                 case 'z':
3688                   flag = 1;
3689                   if (!strncasecmp (s, ",z", 2))
3690                     {
3691                       flag = 0;
3692                       s += 2;
3693                     }
3694
3695                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 10);
3696
3697                 /* Handle add completer.  */
3698                 case 'a':
3699                   flag = 1;
3700                   if (!strncasecmp (s, ",l", 2))
3701                     {
3702                       flag = 2;
3703                       s += 2;
3704                     }
3705                   else if (!strncasecmp (s, ",tsv", 4))
3706                     {
3707                       flag = 3;
3708                       s += 4;
3709                     }
3710
3711                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 10);
3712
3713                 /* Handle 64 bit carry for ADD.  */
3714                 case 'Y':
3715                   flag = 0;
3716                   if (!strncasecmp (s, ",dc,tsv", 7) ||
3717                       !strncasecmp (s, ",tsv,dc", 7))
3718                     {
3719                       flag = 1;
3720                       s += 7;
3721                     }
3722                   else if (!strncasecmp (s, ",dc", 3))
3723                     {
3724                       flag = 0;
3725                       s += 3;
3726                     }
3727                   else
3728                     break;
3729
3730                   /* Condition is not required with "dc".  */
3731                   need_cond = 0;
3732                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3733
3734                 /* Handle 32 bit carry for ADD.  */
3735                 case 'y':
3736                   flag = 0;
3737                   if (!strncasecmp (s, ",c,tsv", 6) ||
3738                       !strncasecmp (s, ",tsv,c", 6))
3739                     {
3740                       flag = 1;
3741                       s += 6;
3742                     }
3743                   else if (!strncasecmp (s, ",c", 2))
3744                     {
3745                       flag = 0;
3746                       s += 2;
3747                     }
3748                   else
3749                     break;
3750
3751                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3752
3753                 /* Handle trap on signed overflow.  */
3754                 case 'v':
3755                   flag = 0;
3756                   if (!strncasecmp (s, ",tsv", 4))
3757                     {
3758                       flag = 1;
3759                       s += 4;
3760                     }
3761
3762                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3763
3764                 /* Handle trap on condition and overflow.  */
3765                 case 't':
3766                   flag = 0;
3767                   if (!strncasecmp (s, ",tc,tsv", 7) ||
3768                       !strncasecmp (s, ",tsv,tc", 7))
3769                     {
3770                       flag = 1;
3771                       s += 7;
3772                     }
3773                   else if (!strncasecmp (s, ",tc", 3))
3774                     {
3775                       flag = 0;
3776                       s += 3;
3777                     }
3778                   else
3779                     break;
3780
3781                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3782
3783                 /* Handle 64 bit borrow for SUB.  */
3784                 case 'B':
3785                   flag = 0;
3786                   if (!strncasecmp (s, ",db,tsv", 7) ||
3787                       !strncasecmp (s, ",tsv,db", 7))
3788                     {
3789                       flag = 1;
3790                       s += 7;
3791                     }
3792                   else if (!strncasecmp (s, ",db", 3))
3793                     {
3794                       flag = 0;
3795                       s += 3;
3796                     }
3797                   else
3798                     break;
3799
3800                   /* Condition is not required with "db".  */
3801                   need_cond = 0;
3802                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3803
3804                 /* Handle 32 bit borrow for SUB.  */
3805                 case 'b':
3806                   flag = 0;
3807                   if (!strncasecmp (s, ",b,tsv", 6) ||
3808                       !strncasecmp (s, ",tsv,b", 6))
3809                     {
3810                       flag = 1;
3811                       s += 6;
3812                     }
3813                   else if (!strncasecmp (s, ",b", 2))
3814                     {
3815                       flag = 0;
3816                       s += 2;
3817                     }
3818                   else
3819                     break;
3820
3821                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3822
3823                 /* Handle trap condition completer for UADDCM.  */
3824                 case 'T':
3825                   flag = 0;
3826                   if (!strncasecmp (s, ",tc", 3))
3827                     {
3828                       flag = 1;
3829                       s += 3;
3830                     }
3831
3832                   INSERT_FIELD_AND_CONTINUE (opcode, flag, 6);
3833
3834                 /* Handle signed/unsigned at 21.  */
3835                 case 'S':
3836                   {
3837                     int sign = 1;
3838                     if (strncasecmp (s, ",s", 2) == 0)
3839                       {
3840                         sign = 1;
3841                         s += 2;
3842                       }
3843                     else if (strncasecmp (s, ",u", 2) == 0)
3844                       {
3845                         sign = 0;
3846                         s += 2;
3847                       }
3848
3849                     INSERT_FIELD_AND_CONTINUE (opcode, sign, 10);
3850                   }
3851
3852                 /* Handle left/right combination at 17:18.  */
3853                 case 'h':
3854                   if (*s++ == ',')
3855                     {
3856                       int lr = 0;
3857                       if (*s == 'r')
3858                         lr = 2;
3859                       else if (*s == 'l')
3860                         lr = 0;
3861                       else
3862                         as_bad (_("Invalid left/right combination completer"));
3863
3864                       s++;
3865                       INSERT_FIELD_AND_CONTINUE (opcode, lr, 13);
3866                     }
3867                   else
3868                     as_bad (_("Invalid left/right combination completer"));
3869                   break;
3870
3871                 /* Handle saturation at 24:25.  */
3872                 case 'H':
3873                   {
3874                     int sat = 3;
3875                     if (strncasecmp (s, ",ss", 3) == 0)
3876                       {
3877                         sat = 1;
3878                         s += 3;
3879                       }
3880                     else if (strncasecmp (s, ",us", 3) == 0)
3881                       {
3882                         sat = 0;
3883                         s += 3;
3884                       }
3885
3886                     INSERT_FIELD_AND_CONTINUE (opcode, sat, 6);
3887                   }
3888
3889                 /* Handle permutation completer.  */
3890                 case '*':
3891                   if (*s++ == ',')
3892                     {
3893                       int permloc[4];
3894                       int perm = 0;
3895                       int i = 0;
3896                       permloc[0] = 13;
3897                       permloc[1] = 10;
3898                       permloc[2] = 8;
3899                       permloc[3] = 6;
3900                       for (; i < 4; i++)
3901                         {
3902                           switch (*s++)
3903                             {
3904                             case '0':
3905                               perm = 0;
3906                               break;
3907                             case '1':
3908                               perm = 1;
3909                               break;
3910                             case '2':
3911                               perm = 2;
3912                               break;
3913                             case '3':
3914                               perm = 3;
3915                               break;
3916                             default:
3917                               as_bad (_("Invalid permutation completer"));
3918                             }
3919                           opcode |= perm << permloc[i];
3920                         }
3921                       continue;
3922                     }
3923                   else
3924                     as_bad (_("Invalid permutation completer"));
3925                   break;
3926
3927                 default:
3928                   abort ();
3929                 }
3930               break;
3931
3932             /* Handle all conditions.  */
3933             case '?':
3934               {
3935                 args++;
3936                 switch (*args)
3937                   {
3938                   /* Handle FP compare conditions.  */
3939                   case 'f':
3940                     cond = pa_parse_fp_cmp_cond (&s);
3941                     INSERT_FIELD_AND_CONTINUE (opcode, cond, 0);
3942
3943                   /* Handle an add condition.  */
3944                   case 'A':
3945                   case 'a':
3946                     cmpltr = 0;
3947                     flag = 0;
3948                     if (*s == ',')
3949                       {
3950                         s++;
3951
3952                         /* 64 bit conditions.  */
3953                         if (*args == 'A')
3954                           {
3955                             if (*s == '*')
3956                               s++;
3957                             else
3958                               break;
3959                           }
3960                         else if (*s == '*')
3961                           break;
3962
3963                         name = s;
3964                         while (*s != ',' && *s != ' ' && *s != '\t')
3965                           s += 1;
3966                         c = *s;
3967                         *s = 0x00;
3968                         if (strcmp (name, "=") == 0)
3969                           cmpltr = 1;
3970                         else if (strcmp (name, "<") == 0)
3971                           cmpltr = 2;
3972                         else if (strcmp (name, "<=") == 0)
3973                           cmpltr = 3;
3974                         else if (strcasecmp (name, "nuv") == 0)
3975                           cmpltr = 4;
3976                         else if (strcasecmp (name, "znv") == 0)
3977                           cmpltr = 5;
3978                         else if (strcasecmp (name, "sv") == 0)
3979                           cmpltr = 6;
3980                         else if (strcasecmp (name, "od") == 0)
3981                           cmpltr = 7;
3982                         else if (strcasecmp (name, "tr") == 0)
3983                           {
3984                             cmpltr = 0;
3985                             flag = 1;
3986                           }
3987                         else if (strcmp (name, "<>") == 0)
3988                           {
3989                             cmpltr = 1;
3990                             flag = 1;
3991                           }
3992                         else if (strcmp (name, ">=") == 0)
3993                           {
3994                             cmpltr = 2;
3995                             flag = 1;
3996                           }
3997                         else if (strcmp (name, ">") == 0)
3998                           {
3999                             cmpltr = 3;
4000                             flag = 1;
4001                           }
4002                         else if (strcasecmp (name, "uv") == 0)
4003                           {
4004                             cmpltr = 4;
4005                             flag = 1;
4006                           }
4007                         else if (strcasecmp (name, "vnz") == 0)
4008                           {
4009                             cmpltr = 5;
4010                             flag = 1;
4011                           }
4012                         else if (strcasecmp (name, "nsv") == 0)
4013                           {
4014                             cmpltr = 6;
4015                             flag = 1;
4016                           }
4017                         else if (strcasecmp (name, "ev") == 0)
4018                           {
4019                             cmpltr = 7;
4020                             flag = 1;
4021                           }
4022                         /* ",*" is a valid condition.  */
4023                         else if (*args == 'a' || *name)
4024                           as_bad (_("Invalid Add Condition: %s"), name);
4025                         *s = c;
4026                       }
4027                     /* Except with "dc", we have a match failure with
4028                        'A' if we don't have a doubleword condition.  */
4029                     else if (*args == 'A' && need_cond)
4030                       break;
4031
4032                     opcode |= cmpltr << 13;
4033                     INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
4034
4035                   /* Handle non-negated add and branch condition.  */
4036                   case 'd':
4037                     cmpltr = pa_parse_nonneg_add_cmpltr (&s);
4038                     if (cmpltr < 0)
4039                       {
4040                         as_bad (_("Invalid Add and Branch Condition"));
4041                         cmpltr = 0;
4042                       }
4043                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4044
4045                   /* Handle 64 bit wide-mode add and branch condition.  */
4046                   case 'W':
4047                     cmpltr = pa_parse_addb_64_cmpltr (&s);
4048                     if (cmpltr < 0)
4049                       {
4050                         as_bad (_("Invalid Add and Branch Condition"));
4051                         cmpltr = 0;
4052                       }
4053                     else
4054                       {
4055                         /* Negated condition requires an opcode change.  */
4056                         opcode |= (cmpltr & 8) << 24;
4057                       }
4058                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr & 7, 13);
4059
4060                   /* Handle a negated or non-negated add and branch
4061                      condition.  */
4062                   case '@':
4063                     save_s = s;
4064                     cmpltr = pa_parse_nonneg_add_cmpltr (&s);
4065                     if (cmpltr < 0)
4066                       {
4067                         s = save_s;
4068                         cmpltr = pa_parse_neg_add_cmpltr (&s);
4069                         if (cmpltr < 0)
4070                           {
4071                             as_bad (_("Invalid Compare/Subtract Condition"));
4072                             cmpltr = 0;
4073                           }
4074                         else
4075                           {
4076                             /* Negated condition requires an opcode change.  */
4077                             opcode |= 1 << 27;
4078                           }
4079                       }
4080                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4081
4082                   /* Handle branch on bit conditions.  */
4083                   case 'B':
4084                   case 'b':
4085                     cmpltr = 0;
4086                     if (*s == ',')
4087                       {
4088                         s++;
4089
4090                         if (*args == 'B')
4091                           {
4092                             if (*s == '*')
4093                               s++;
4094                             else
4095                               break;
4096                           }
4097                         else if (*s == '*')
4098                           break;
4099
4100                         if (strncmp (s, "<", 1) == 0)
4101                           {
4102                             cmpltr = 0;
4103                             s++;
4104                           }
4105                         else if (strncmp (s, ">=", 2) == 0)
4106                           {
4107                             cmpltr = 1;
4108                             s += 2;
4109                           }
4110                         else
4111                           as_bad (_("Invalid Branch On Bit Condition: %c"), *s);
4112                       }
4113                     else
4114                       as_bad (_("Missing Branch On Bit Condition"));
4115
4116                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 15);
4117
4118                   /* Handle a compare/subtract condition.  */
4119                   case 'S':
4120                   case 's':
4121                     cmpltr = 0;
4122                     flag = 0;
4123                     if (*s == ',')
4124                       {
4125                         s++;
4126
4127                         /* 64 bit conditions.  */
4128                         if (*args == 'S')
4129                           {
4130                             if (*s == '*')
4131                               s++;
4132                             else
4133                               break;
4134                           }
4135                         else if (*s == '*')
4136                           break;
4137
4138                         name = s;
4139                         while (*s != ',' && *s != ' ' && *s != '\t')
4140                           s += 1;
4141                         c = *s;
4142                         *s = 0x00;
4143                         if (strcmp (name, "=") == 0)
4144                           cmpltr = 1;
4145                         else if (strcmp (name, "<") == 0)
4146                           cmpltr = 2;
4147                         else if (strcmp (name, "<=") == 0)
4148                           cmpltr = 3;
4149                         else if (strcasecmp (name, "<<") == 0)
4150                           cmpltr = 4;
4151                         else if (strcasecmp (name, "<<=") == 0)
4152                           cmpltr = 5;
4153                         else if (strcasecmp (name, "sv") == 0)
4154                           cmpltr = 6;
4155                         else if (strcasecmp (name, "od") == 0)
4156                           cmpltr = 7;
4157                         else if (strcasecmp (name, "tr") == 0)
4158                           {
4159                             cmpltr = 0;
4160                             flag = 1;
4161                           }
4162                         else if (strcmp (name, "<>") == 0)
4163                           {
4164                             cmpltr = 1;
4165                             flag = 1;
4166                           }
4167                         else if (strcmp (name, ">=") == 0)
4168                           {
4169                             cmpltr = 2;
4170                             flag = 1;
4171                           }
4172                         else if (strcmp (name, ">") == 0)
4173                           {
4174                             cmpltr = 3;
4175                             flag = 1;
4176                           }
4177                         else if (strcasecmp (name, ">>=") == 0)
4178                           {
4179                             cmpltr = 4;
4180                             flag = 1;
4181                           }
4182                         else if (strcasecmp (name, ">>") == 0)
4183                           {
4184                             cmpltr = 5;
4185                             flag = 1;
4186                           }
4187                         else if (strcasecmp (name, "nsv") == 0)
4188                           {
4189                             cmpltr = 6;
4190                             flag = 1;
4191                           }
4192                         else if (strcasecmp (name, "ev") == 0)
4193                           {
4194                             cmpltr = 7;
4195                             flag = 1;
4196                           }
4197                         /* ",*" is a valid condition.  */
4198                         else if (*args != 'S' || *name)
4199                           as_bad (_("Invalid Compare/Subtract Condition: %s"),
4200                                   name);
4201                         *s = c;
4202                       }
4203                     /* Except with "db", we have a match failure with
4204                        'S' if we don't have a doubleword condition.  */
4205                     else if (*args == 'S' && need_cond)
4206                       break;
4207
4208                     opcode |= cmpltr << 13;
4209                     INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
4210
4211                   /* Handle a non-negated compare condition.  */
4212                   case 't':
4213                     cmpltr = pa_parse_nonneg_cmpsub_cmpltr (&s);
4214                     if (cmpltr < 0)
4215                       {
4216                         as_bad (_("Invalid Compare/Subtract Condition"));
4217                         cmpltr = 0;
4218                       }
4219                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4220
4221                   /* Handle a 32 bit compare and branch condition.  */
4222                   case 'n':
4223                     save_s = s;
4224                     cmpltr = pa_parse_nonneg_cmpsub_cmpltr (&s);
4225                     if (cmpltr < 0)
4226                       {
4227                         s = save_s;
4228                         cmpltr = pa_parse_neg_cmpsub_cmpltr (&s);
4229                         if (cmpltr < 0)
4230                           {
4231                             as_bad (_("Invalid Compare and Branch Condition"));
4232                             cmpltr = 0;
4233                           }
4234                         else
4235                           {
4236                             /* Negated condition requires an opcode change.  */
4237                             opcode |= 1 << 27;
4238                           }
4239                       }
4240
4241                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4242
4243                   /* Handle a 64 bit compare and branch condition.  */
4244                   case 'N':
4245                     cmpltr = pa_parse_cmpb_64_cmpltr (&s);
4246                     if (cmpltr >= 0)
4247                       {
4248                         /* Negated condition requires an opcode change.  */
4249                         opcode |= (cmpltr & 8) << 26;
4250                       }
4251                     else
4252                       /* Not a 64 bit cond.  Give 32 bit a chance.  */
4253                       break;
4254
4255                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr & 7, 13);
4256
4257                   /* Handle a 64 bit cmpib condition.  */
4258                   case 'Q':
4259                     cmpltr = pa_parse_cmpib_64_cmpltr (&s);
4260                     if (cmpltr < 0)
4261                       /* Not a 64 bit cond.  Give 32 bit a chance.  */
4262                       break;
4263
4264                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4265
4266                   /* Handle a logical instruction condition.  */
4267                   case 'L':
4268                   case 'l':
4269                     cmpltr = 0;
4270                     flag = 0;
4271                     if (*s == ',')
4272                       {
4273                         s++;
4274
4275                         /* 64 bit conditions.  */
4276                         if (*args == 'L')
4277                           {
4278                             if (*s == '*')
4279                               s++;
4280                             else
4281                               break;
4282                           }
4283                         else if (*s == '*')
4284                           break;
4285
4286                         name = s;
4287                         while (*s != ',' && *s != ' ' && *s != '\t')
4288                           s += 1;
4289                         c = *s;
4290                         *s = 0x00;
4291
4292                         if (strcmp (name, "=") == 0)
4293                           cmpltr = 1;
4294                         else if (strcmp (name, "<") == 0)
4295                           cmpltr = 2;
4296                         else if (strcmp (name, "<=") == 0)
4297                           cmpltr = 3;
4298                         else if (strcasecmp (name, "od") == 0)
4299                           cmpltr = 7;
4300                         else if (strcasecmp (name, "tr") == 0)
4301                           {
4302                             cmpltr = 0;
4303                             flag = 1;
4304                           }
4305                         else if (strcmp (name, "<>") == 0)
4306                           {
4307                             cmpltr = 1;
4308                             flag = 1;
4309                           }
4310                         else if (strcmp (name, ">=") == 0)
4311                           {
4312                             cmpltr = 2;
4313                             flag = 1;
4314                           }
4315                         else if (strcmp (name, ">") == 0)
4316                           {
4317                             cmpltr = 3;
4318                             flag = 1;
4319                           }
4320                         else if (strcasecmp (name, "ev") == 0)
4321                           {
4322                             cmpltr = 7;
4323                             flag = 1;
4324                           }
4325                         /* ",*" is a valid condition.  */
4326                         else if (*args != 'L' || *name)
4327                           as_bad (_("Invalid Logical Instruction Condition."));
4328                         *s = c;
4329                       }
4330                     /* 32-bit is default for no condition.  */
4331                     else if (*args == 'L')
4332                       break;
4333
4334                     opcode |= cmpltr << 13;
4335                     INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
4336
4337                   /* Handle a shift/extract/deposit condition.  */
4338                   case 'X':
4339                   case 'x':
4340                   case 'y':
4341                     cmpltr = 0;
4342                     /* Check immediate values in shift/extract/deposit
4343                      * instructions if they will give undefined behaviour.  */
4344                     immediate_check = 1;
4345                     if (*s == ',')
4346                       {
4347                         save_s = s++;
4348
4349                         /* 64 bit conditions.  */
4350                         if (*args == 'X')
4351                           {
4352                             if (*s == '*')
4353                               s++;
4354                             else
4355                               break;
4356                           }
4357                         else if (*s == '*')
4358                           break;
4359
4360                         name = s;
4361                         while (*s != ',' && *s != ' ' && *s != '\t')
4362                           s += 1;
4363                         c = *s;
4364                         *s = 0x00;
4365                         if (strcmp (name, "=") == 0)
4366                           cmpltr = 1;
4367                         else if (strcmp (name, "<") == 0)
4368                           cmpltr = 2;
4369                         else if (strcasecmp (name, "od") == 0)
4370                           cmpltr = 3;
4371                         else if (strcasecmp (name, "tr") == 0)
4372                           cmpltr = 4;
4373                         else if (strcmp (name, "<>") == 0)
4374                           cmpltr = 5;
4375                         else if (strcmp (name, ">=") == 0)
4376                           cmpltr = 6;
4377                         else if (strcasecmp (name, "ev") == 0)
4378                           cmpltr = 7;
4379                         /* Handle movb,n.  Put things back the way they were.
4380                            This includes moving s back to where it started.  */
4381                         else if (strcasecmp (name, "n") == 0 && *args == 'y')
4382                           {
4383                             *s = c;
4384                             s = save_s;
4385                             continue;
4386                           }
4387                         /* ",*" is a valid condition.  */
4388                         else if (*args != 'X' || *name)
4389                           as_bad (_("Invalid Shift/Extract/Deposit Condition."));
4390                         *s = c;
4391                       }
4392
4393                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4394
4395                   /* Handle a unit instruction condition.  */
4396                   case 'U':
4397                   case 'u':
4398                     cmpltr = 0;
4399                     flag = 0;
4400                     if (*s == ',')
4401                       {
4402                         int uxor;
4403                         s++;
4404
4405                         /* 64 bit conditions.  */
4406                         if (*args == 'U')
4407                           {
4408                             if (*s == '*')
4409                               s++;
4410                             else
4411                               break;
4412                           }
4413                         else if (*s == '*')
4414                           break;
4415
4416                         /* The uxor instruction only supports unit conditions
4417                            not involving carries.  */
4418                         uxor = (opcode & 0xfc000fc0) == 0x08000380;
4419                         if (strncasecmp (s, "sbz", 3) == 0)
4420                           {
4421                             cmpltr = 2;
4422                             s += 3;
4423                           }
4424                         else if (strncasecmp (s, "shz", 3) == 0)
4425                           {
4426                             cmpltr = 3;
4427                             s += 3;
4428                           }
4429                         else if (!uxor && strncasecmp (s, "sdc", 3) == 0)
4430                           {
4431                             cmpltr = 4;
4432                             s += 3;
4433                           }
4434                         else if (!uxor && strncasecmp (s, "sbc", 3) == 0)
4435                           {
4436                             cmpltr = 6;
4437                             s += 3;
4438                           }
4439                         else if (!uxor && strncasecmp (s, "shc", 3) == 0)
4440                           {
4441                             cmpltr = 7;
4442                             s += 3;
4443                           }
4444                         else if (strncasecmp (s, "tr", 2) == 0)
4445                           {
4446                             cmpltr = 0;
4447                             flag = 1;
4448                             s += 2;
4449                           }
4450                         else if (strncasecmp (s, "nbz", 3) == 0)
4451                           {
4452                             cmpltr = 2;
4453                             flag = 1;
4454                             s += 3;
4455                           }
4456                         else if (strncasecmp (s, "nhz", 3) == 0)
4457                           {
4458                             cmpltr = 3;
4459                             flag = 1;
4460                             s += 3;
4461                           }
4462                         else if (!uxor && strncasecmp (s, "ndc", 3) == 0)
4463                           {
4464                             cmpltr = 4;
4465                             flag = 1;
4466                             s += 3;
4467                           }
4468                         else if (!uxor && strncasecmp (s, "nbc", 3) == 0)
4469                           {
4470                             cmpltr = 6;
4471                             flag = 1;
4472                             s += 3;
4473                           }
4474                         else if (!uxor && strncasecmp (s, "nhc", 3) == 0)
4475                           {
4476                             cmpltr = 7;
4477                             flag = 1;
4478                             s += 3;
4479                           }
4480                         else if (strncasecmp (s, "swz", 3) == 0)
4481                           {
4482                             cmpltr = 1;
4483                             flag = 0;
4484                             s += 3;
4485                           }
4486                         else if (!uxor && strncasecmp (s, "swc", 3) == 0)
4487                           {
4488                             cmpltr = 5;
4489                             flag = 0;
4490                             s += 3;
4491                           }
4492                         else if (strncasecmp (s, "nwz", 3) == 0)
4493                           {
4494                             cmpltr = 1;
4495                             flag = 1;
4496                             s += 3;
4497                           }
4498                         else if (!uxor && strncasecmp (s, "nwc", 3) == 0)
4499                           {
4500                             cmpltr = 5;
4501                             flag = 1;
4502                             s += 3;
4503                           }
4504                         /* ",*" is a valid condition.  */
4505                         else if (*args != 'U' || (*s != ' ' && *s != '\t'))
4506                           as_bad (_("Invalid Unit Instruction Condition."));
4507                       }
4508                     /* 32-bit is default for no condition.  */
4509                     else if (*args == 'U')
4510                       break;
4511
4512                     opcode |= cmpltr << 13;
4513                     INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
4514
4515                   default:
4516                     abort ();
4517                   }
4518                 break;
4519               }
4520
4521             /* Handle a nullification completer for branch instructions.  */
4522             case 'n':
4523               nullif = pa_parse_nullif (&s);
4524               INSERT_FIELD_AND_CONTINUE (opcode, nullif, 1);
4525
4526             /* Handle a nullification completer for copr and spop insns.  */
4527             case 'N':
4528               nullif = pa_parse_nullif (&s);
4529               INSERT_FIELD_AND_CONTINUE (opcode, nullif, 5);
4530
4531             /* Handle ,%r2 completer for new syntax branches.  */
4532             case 'L':
4533               if (*s == ',' && strncasecmp (s + 1, "%r2", 3) == 0)
4534                 s += 4;
4535               else if (*s == ',' && strncasecmp (s + 1, "%rp", 3) == 0)
4536                 s += 4;
4537               else
4538                 break;
4539               continue;
4540
4541             /* Handle 3 bit entry into the fp compare array.   Valid values
4542                are 0..6 inclusive.  */
4543             case 'h':
4544               get_expression (s);
4545               s = expr_end;
4546               if (the_insn.exp.X_op == O_constant)
4547                 {
4548                   num = evaluate_absolute (&the_insn);
4549                   CHECK_FIELD (num, 6, 0, 0);
4550                   num++;
4551                   INSERT_FIELD_AND_CONTINUE (opcode, num, 13);
4552                 }
4553               else
4554                 break;
4555
4556             /* Handle 3 bit entry into the fp compare array.   Valid values
4557                are 0..6 inclusive.  */
4558             case 'm':
4559               get_expression (s);
4560               if (the_insn.exp.X_op == O_constant)
4561                 {
4562                   s = expr_end;
4563                   num = evaluate_absolute (&the_insn);
4564                   CHECK_FIELD (num, 6, 0, 0);
4565                   num = (num + 1) ^ 1;
4566                   INSERT_FIELD_AND_CONTINUE (opcode, num, 13);
4567                 }
4568               else
4569                 break;
4570
4571             /* Handle graphics test completers for ftest */
4572             case '=':
4573               {
4574                 num = pa_parse_ftest_gfx_completer (&s);
4575                 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4576               }
4577
4578             /* Handle a 11 bit immediate at 31.  */
4579             case 'i':
4580               the_insn.field_selector = pa_chk_field_selector (&s);
4581               get_expression (s);
4582               s = expr_end;
4583               if (the_insn.exp.X_op == O_constant)
4584                 {
4585                   num = evaluate_absolute (&the_insn);
4586                   CHECK_FIELD (num, 1023, -1024, 0);
4587                   num = low_sign_unext (num, 11);
4588                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4589                 }
4590               else
4591                 {
4592                   if (is_DP_relative (the_insn.exp))
4593                     the_insn.reloc = R_HPPA_GOTOFF;
4594                   else if (is_PC_relative (the_insn.exp))
4595                     the_insn.reloc = R_HPPA_PCREL_CALL;
4596 #ifdef OBJ_ELF
4597                   else if (is_tls_gdidx (the_insn.exp))
4598                     the_insn.reloc = R_PARISC_TLS_GD21L;
4599                   else if (is_tls_ldidx (the_insn.exp))
4600                     the_insn.reloc = R_PARISC_TLS_LDM21L;
4601                   else if (is_tls_dtpoff (the_insn.exp))
4602                     the_insn.reloc = R_PARISC_TLS_LDO21L;
4603                   else if (is_tls_ieoff (the_insn.exp))
4604                     the_insn.reloc = R_PARISC_TLS_IE21L;
4605                   else if (is_tls_leoff (the_insn.exp))
4606                     the_insn.reloc = R_PARISC_TLS_LE21L;
4607 #endif
4608                   else
4609                     the_insn.reloc = R_HPPA;
4610                   the_insn.format = 11;
4611                   continue;
4612                 }
4613
4614             /* Handle a 14 bit immediate at 31.  */
4615             case 'J':
4616               the_insn.field_selector = pa_chk_field_selector (&s);
4617               get_expression (s);
4618               s = expr_end;
4619               if (the_insn.exp.X_op == O_constant)
4620                 {
4621                   int mb;
4622
4623                   /* XXX the completer stored away tidbits of information
4624                      for us to extract.  We need a cleaner way to do this.
4625                      Now that we have lots of letters again, it would be
4626                      good to rethink this.  */
4627                   mb = opcode & 1;
4628                   opcode -= mb;
4629                   num = evaluate_absolute (&the_insn);
4630                   if (mb != (num < 0))
4631                     break;
4632                   CHECK_FIELD (num, 8191, -8192, 0);
4633                   num = low_sign_unext (num, 14);
4634                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4635                 }
4636               break;
4637
4638             /* Handle a 14 bit immediate at 31.  */
4639             case 'K':
4640               the_insn.field_selector = pa_chk_field_selector (&s);
4641               get_expression (s);
4642               s = expr_end;
4643               if (the_insn.exp.X_op == O_constant)
4644                 {
4645                   int mb;
4646
4647                   mb = opcode & 1;
4648                   opcode -= mb;
4649                   num = evaluate_absolute (&the_insn);
4650                   if (mb == (num < 0))
4651                     break;
4652                   if (num % 4)
4653                     break;
4654                   CHECK_FIELD (num, 8191, -8192, 0);
4655                   num = low_sign_unext (num, 14);
4656                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4657                 }
4658               break;
4659
4660             /* Handle a 16 bit immediate at 31.  */
4661             case '<':
4662               the_insn.field_selector = pa_chk_field_selector (&s);
4663               get_expression (s);
4664               s = expr_end;
4665               if (the_insn.exp.X_op == O_constant)
4666                 {
4667                   int mb;
4668
4669                   mb = opcode & 1;
4670                   opcode -= mb;
4671                   num = evaluate_absolute (&the_insn);
4672                   if (mb != (num < 0))
4673                     break;
4674                   CHECK_FIELD (num, 32767, -32768, 0);
4675                   num = re_assemble_16 (num);
4676                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4677                 }
4678               break;
4679
4680             /* Handle a 16 bit immediate at 31.  */
4681             case '>':
4682               the_insn.field_selector = pa_chk_field_selector (&s);
4683               get_expression (s);
4684               s = expr_end;
4685               if (the_insn.exp.X_op == O_constant)
4686                 {
4687                   int mb;
4688
4689                   mb = opcode & 1;
4690                   opcode -= mb;
4691                   num = evaluate_absolute (&the_insn);
4692                   if (mb == (num < 0))
4693                     break;
4694                   if (num % 4)
4695                     break;
4696                   CHECK_FIELD (num, 32767, -32768, 0);
4697                   num = re_assemble_16 (num);
4698                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4699                 }
4700               break;
4701
4702             /* Handle 14 bit immediate, shifted left three times.  */
4703             case '#':
4704               if (bfd_get_mach (stdoutput) != pa20)
4705                 break;
4706               the_insn.field_selector = pa_chk_field_selector (&s);
4707               get_expression (s);
4708               s = expr_end;
4709               if (the_insn.exp.X_op == O_constant)
4710                 {
4711                   num = evaluate_absolute (&the_insn);
4712                   if (num & 0x7)
4713                     break;
4714                   CHECK_FIELD (num, 8191, -8192, 0);
4715                   if (num < 0)
4716                     opcode |= 1;
4717                   num &= 0x1fff;
4718                   num >>= 3;
4719                   INSERT_FIELD_AND_CONTINUE (opcode, num, 4);
4720                 }
4721               else
4722                 {
4723                   if (is_DP_relative (the_insn.exp))
4724                     the_insn.reloc = R_HPPA_GOTOFF;
4725                   else if (is_PC_relative (the_insn.exp))
4726                     the_insn.reloc = R_HPPA_PCREL_CALL;
4727 #ifdef OBJ_ELF
4728                   else if (is_tls_gdidx (the_insn.exp))
4729                     the_insn.reloc = R_PARISC_TLS_GD21L;
4730                   else if (is_tls_ldidx (the_insn.exp))
4731                     the_insn.reloc = R_PARISC_TLS_LDM21L;
4732                   else if (is_tls_dtpoff (the_insn.exp))
4733                     the_insn.reloc = R_PARISC_TLS_LDO21L;
4734                   else if (is_tls_ieoff (the_insn.exp))
4735                     the_insn.reloc = R_PARISC_TLS_IE21L;
4736                   else if (is_tls_leoff (the_insn.exp))
4737                     the_insn.reloc = R_PARISC_TLS_LE21L;
4738 #endif
4739                   else
4740                     the_insn.reloc = R_HPPA;
4741                   the_insn.format = 14;
4742                   continue;
4743                 }
4744               break;
4745
4746             /* Handle 14 bit immediate, shifted left twice.  */
4747             case 'd':
4748               the_insn.field_selector = pa_chk_field_selector (&s);
4749               get_expression (s);
4750               s = expr_end;
4751               if (the_insn.exp.X_op == O_constant)
4752                 {
4753                   num = evaluate_absolute (&the_insn);
4754                   if (num & 0x3)
4755                     break;
4756                   CHECK_FIELD (num, 8191, -8192, 0);
4757                   if (num < 0)
4758                     opcode |= 1;
4759                   num &= 0x1fff;
4760                   num >>= 2;
4761                   INSERT_FIELD_AND_CONTINUE (opcode, num, 3);
4762                 }
4763               else
4764                 {
4765                   if (is_DP_relative (the_insn.exp))
4766                     the_insn.reloc = R_HPPA_GOTOFF;
4767                   else if (is_PC_relative (the_insn.exp))
4768                     the_insn.reloc = R_HPPA_PCREL_CALL;
4769 #ifdef OBJ_ELF
4770                   else if (is_tls_gdidx (the_insn.exp))
4771                     the_insn.reloc = R_PARISC_TLS_GD21L;
4772                   else if (is_tls_ldidx (the_insn.exp))
4773                     the_insn.reloc = R_PARISC_TLS_LDM21L;
4774                   else if (is_tls_dtpoff (the_insn.exp))
4775                     the_insn.reloc = R_PARISC_TLS_LDO21L;
4776                   else if (is_tls_ieoff (the_insn.exp))
4777                     the_insn.reloc = R_PARISC_TLS_IE21L;
4778                   else if (is_tls_leoff (the_insn.exp))
4779                     the_insn.reloc = R_PARISC_TLS_LE21L;
4780 #endif
4781                   else
4782                     the_insn.reloc = R_HPPA;
4783                   the_insn.format = 14;
4784                   continue;
4785                 }
4786
4787             /* Handle a 14 bit immediate at 31.  */
4788             case 'j':
4789               the_insn.field_selector = pa_chk_field_selector (&s);
4790               get_expression (s);
4791               s = expr_end;
4792               if (the_insn.exp.X_op == O_constant)
4793                 {
4794                   num = evaluate_absolute (&the_insn);
4795                   CHECK_FIELD (num, 8191, -8192, 0);
4796                   num = low_sign_unext (num, 14);
4797                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4798                 }
4799               else
4800                 {
4801                   if (is_DP_relative (the_insn.exp))
4802                     the_insn.reloc = R_HPPA_GOTOFF;
4803                   else if (is_PC_relative (the_insn.exp))
4804                     the_insn.reloc = R_HPPA_PCREL_CALL;
4805 #ifdef OBJ_ELF
4806                   else if (is_tls_gdidx (the_insn.exp))
4807                     the_insn.reloc = R_PARISC_TLS_GD21L;
4808                   else if (is_tls_ldidx (the_insn.exp))
4809                     the_insn.reloc = R_PARISC_TLS_LDM21L;
4810                   else if (is_tls_dtpoff (the_insn.exp))
4811                     the_insn.reloc = R_PARISC_TLS_LDO21L;
4812                   else if (is_tls_ieoff (the_insn.exp))
4813                     the_insn.reloc = R_PARISC_TLS_IE21L;
4814                   else if (is_tls_leoff (the_insn.exp))
4815                     the_insn.reloc = R_PARISC_TLS_LE21L;
4816 #endif
4817                   else
4818                     the_insn.reloc = R_HPPA;
4819                   the_insn.format = 14;
4820                   continue;
4821                 }
4822
4823             /* Handle a 21 bit immediate at 31.  */
4824             case 'k':
4825               the_insn.field_selector = pa_chk_field_selector (&s);
4826               get_expression (s);
4827               s = expr_end;
4828               if (the_insn.exp.X_op == O_constant)
4829                 {
4830                   num = evaluate_absolute (&the_insn);
4831                   CHECK_FIELD (num >> 11, 1048575, -1048576, 0);
4832                   opcode |= re_assemble_21 (num);
4833                   continue;
4834                 }
4835               else
4836                 {
4837                   if (is_DP_relative (the_insn.exp))
4838                     the_insn.reloc = R_HPPA_GOTOFF;
4839                   else if (is_PC_relative (the_insn.exp))
4840                     the_insn.reloc = R_HPPA_PCREL_CALL;
4841 #ifdef OBJ_ELF
4842                   else if (is_tls_gdidx (the_insn.exp))
4843                     the_insn.reloc = R_PARISC_TLS_GD21L;
4844                   else if (is_tls_ldidx (the_insn.exp))
4845                     the_insn.reloc = R_PARISC_TLS_LDM21L;
4846                   else if (is_tls_dtpoff (the_insn.exp))
4847                     the_insn.reloc = R_PARISC_TLS_LDO21L;
4848                   else if (is_tls_ieoff (the_insn.exp))
4849                     the_insn.reloc = R_PARISC_TLS_IE21L;
4850                   else if (is_tls_leoff (the_insn.exp))
4851                     the_insn.reloc = R_PARISC_TLS_LE21L;
4852 #endif
4853                   else
4854                     the_insn.reloc = R_HPPA;
4855                   the_insn.format = 21;
4856                   continue;
4857                 }
4858
4859             /* Handle a 16 bit immediate at 31 (PA 2.0 wide mode only).  */
4860             case 'l':
4861               the_insn.field_selector = pa_chk_field_selector (&s);
4862               get_expression (s);
4863               s = expr_end;
4864               if (the_insn.exp.X_op == O_constant)
4865                 {
4866                   num = evaluate_absolute (&the_insn);
4867                   CHECK_FIELD (num, 32767, -32768, 0);
4868                   opcode |= re_assemble_16 (num);
4869                   continue;
4870                 }
4871               else
4872                 {
4873                   /* ??? Is this valid for wide mode?  */
4874                   if (is_DP_relative (the_insn.exp))
4875                     the_insn.reloc = R_HPPA_GOTOFF;
4876                   else if (is_PC_relative (the_insn.exp))
4877                     the_insn.reloc = R_HPPA_PCREL_CALL;
4878 #ifdef OBJ_ELF
4879                   else if (is_tls_gdidx (the_insn.exp))
4880                     the_insn.reloc = R_PARISC_TLS_GD21L;
4881                   else if (is_tls_ldidx (the_insn.exp))
4882                     the_insn.reloc = R_PARISC_TLS_LDM21L;
4883                   else if (is_tls_dtpoff (the_insn.exp))
4884                     the_insn.reloc = R_PARISC_TLS_LDO21L;
4885                   else if (is_tls_ieoff (the_insn.exp))
4886                     the_insn.reloc = R_PARISC_TLS_IE21L;
4887                   else if (is_tls_leoff (the_insn.exp))
4888                     the_insn.reloc = R_PARISC_TLS_LE21L;
4889 #endif
4890                   else
4891                     the_insn.reloc = R_HPPA;
4892                   the_insn.format = 14;
4893                   continue;
4894                 }
4895
4896             /* Handle a word-aligned 16-bit imm. at 31 (PA2.0 wide).  */
4897             case 'y':
4898               the_insn.field_selector = pa_chk_field_selector (&s);
4899               get_expression (s);
4900               s = expr_end;
4901               if (the_insn.exp.X_op == O_constant)
4902                 {
4903                   num = evaluate_absolute (&the_insn);
4904                   CHECK_FIELD (num, 32767, -32768, 0);
4905                   CHECK_ALIGN (num, 4, 0);
4906                   opcode |= re_assemble_16 (num);
4907                   continue;
4908                 }
4909               else
4910                 {
4911                   /* ??? Is this valid for wide mode?  */
4912                   if (is_DP_relative (the_insn.exp))
4913                     the_insn.reloc = R_HPPA_GOTOFF;
4914                   else if (is_PC_relative (the_insn.exp))
4915                     the_insn.reloc = R_HPPA_PCREL_CALL;
4916 #ifdef OBJ_ELF
4917                   else if (is_tls_gdidx (the_insn.exp))
4918                     the_insn.reloc = R_PARISC_TLS_GD21L;
4919                   else if (is_tls_ldidx (the_insn.exp))
4920                     the_insn.reloc = R_PARISC_TLS_LDM21L;
4921                   else if (is_tls_dtpoff (the_insn.exp))
4922                     the_insn.reloc = R_PARISC_TLS_LDO21L;
4923                   else if (is_tls_ieoff (the_insn.exp))
4924                     the_insn.reloc = R_PARISC_TLS_IE21L;
4925                   else if (is_tls_leoff (the_insn.exp))
4926                     the_insn.reloc = R_PARISC_TLS_LE21L;
4927 #endif
4928                   else
4929                     the_insn.reloc = R_HPPA;
4930                   the_insn.format = 14;
4931                   continue;
4932                 }
4933
4934             /* Handle a dword-aligned 16-bit imm. at 31 (PA2.0 wide).  */
4935             case '&':
4936               the_insn.field_selector = pa_chk_field_selector (&s);
4937               get_expression (s);
4938               s = expr_end;
4939               if (the_insn.exp.X_op == O_constant)
4940                 {
4941                   num = evaluate_absolute (&the_insn);
4942                   CHECK_FIELD (num, 32767, -32768, 0);
4943                   CHECK_ALIGN (num, 8, 0);
4944                   opcode |= re_assemble_16 (num);
4945                   continue;
4946                 }
4947               else
4948                 {
4949                   /* ??? Is this valid for wide mode?  */
4950                   if (is_DP_relative (the_insn.exp))
4951                     the_insn.reloc = R_HPPA_GOTOFF;
4952                   else if (is_PC_relative (the_insn.exp))
4953                     the_insn.reloc = R_HPPA_PCREL_CALL;
4954 #ifdef OBJ_ELF
4955                   else if (is_tls_gdidx (the_insn.exp))
4956                     the_insn.reloc = R_PARISC_TLS_GD21L;
4957                   else if (is_tls_ldidx (the_insn.exp))
4958                     the_insn.reloc = R_PARISC_TLS_LDM21L;
4959                   else if (is_tls_dtpoff (the_insn.exp))
4960                     the_insn.reloc = R_PARISC_TLS_LDO21L;
4961                   else if (is_tls_ieoff (the_insn.exp))
4962                     the_insn.reloc = R_PARISC_TLS_IE21L;
4963                   else if (is_tls_leoff (the_insn.exp))
4964                     the_insn.reloc = R_PARISC_TLS_LE21L;
4965 #endif
4966                   else
4967                     the_insn.reloc = R_HPPA;
4968                   the_insn.format = 14;
4969                   continue;
4970                 }
4971
4972             /* Handle a 12 bit branch displacement.  */
4973             case 'w':
4974               the_insn.field_selector = pa_chk_field_selector (&s);
4975               get_expression (s);
4976               s = expr_end;
4977               the_insn.pcrel = 1;
4978               if (!the_insn.exp.X_add_symbol
4979                   || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
4980                               FAKE_LABEL_NAME))
4981                 {
4982                   num = evaluate_absolute (&the_insn);
4983                   if (num % 4)
4984                     {
4985                       as_bad (_("Branch to unaligned address"));
4986                       break;
4987                     }
4988                   if (the_insn.exp.X_add_symbol)
4989                     num -= 8;
4990                   CHECK_FIELD (num, 8191, -8192, 0);
4991                   opcode |= re_assemble_12 (num >> 2);
4992                   continue;
4993                 }
4994               else
4995                 {
4996                   the_insn.reloc = R_HPPA_PCREL_CALL;
4997                   the_insn.format = 12;
4998                   the_insn.arg_reloc = last_call_desc.arg_reloc;
4999                   memset (&last_call_desc, 0, sizeof (struct call_desc));
5000                   s = expr_end;
5001                   continue;
5002                 }
5003
5004             /* Handle a 17 bit branch displacement.  */
5005             case 'W':
5006               the_insn.field_selector = pa_chk_field_selector (&s);
5007               get_expression (s);
5008               s = expr_end;
5009               the_insn.pcrel = 1;
5010               if (!the_insn.exp.X_add_symbol
5011                   || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
5012                               FAKE_LABEL_NAME))
5013                 {
5014                   num = evaluate_absolute (&the_insn);
5015                   if (num % 4)
5016                     {
5017                       as_bad (_("Branch to unaligned address"));
5018                       break;
5019                     }
5020                   if (the_insn.exp.X_add_symbol)
5021                     num -= 8;
5022                   CHECK_FIELD (num, 262143, -262144, 0);
5023                   opcode |= re_assemble_17 (num >> 2);
5024                   continue;
5025                 }
5026               else
5027                 {
5028                   the_insn.reloc = R_HPPA_PCREL_CALL;
5029                   the_insn.format = 17;
5030                   the_insn.arg_reloc = last_call_desc.arg_reloc;
5031                   memset (&last_call_desc, 0, sizeof (struct call_desc));
5032                   continue;
5033                 }
5034
5035             /* Handle a 22 bit branch displacement.  */
5036             case 'X':
5037               the_insn.field_selector = pa_chk_field_selector (&s);
5038               get_expression (s);
5039               s = expr_end;
5040               the_insn.pcrel = 1;
5041               if (!the_insn.exp.X_add_symbol
5042                   || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
5043                               FAKE_LABEL_NAME))
5044                 {
5045                   num = evaluate_absolute (&the_insn);
5046                   if (num % 4)
5047                     {
5048                       as_bad (_("Branch to unaligned address"));
5049                       break;
5050                     }
5051                   if (the_insn.exp.X_add_symbol)
5052                     num -= 8;
5053                   CHECK_FIELD (num, 8388607, -8388608, 0);
5054                   opcode |= re_assemble_22 (num >> 2);
5055                 }
5056               else
5057                 {
5058                   the_insn.reloc = R_HPPA_PCREL_CALL;
5059                   the_insn.format = 22;
5060                   the_insn.arg_reloc = last_call_desc.arg_reloc;
5061                   memset (&last_call_desc, 0, sizeof (struct call_desc));
5062                   continue;
5063                 }
5064
5065             /* Handle an absolute 17 bit branch target.  */
5066             case 'z':
5067               the_insn.field_selector = pa_chk_field_selector (&s);
5068               get_expression (s);
5069               s = expr_end;
5070               the_insn.pcrel = 0;
5071               if (!the_insn.exp.X_add_symbol
5072                   || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
5073                               FAKE_LABEL_NAME))
5074                 {
5075                   num = evaluate_absolute (&the_insn);
5076                   if (num % 4)
5077                     {
5078                       as_bad (_("Branch to unaligned address"));
5079                       break;
5080                     }
5081                   if (the_insn.exp.X_add_symbol)
5082                     num -= 8;
5083                   CHECK_FIELD (num, 262143, -262144, 0);
5084                   opcode |= re_assemble_17 (num >> 2);
5085                   continue;
5086                 }
5087               else
5088                 {
5089                   the_insn.reloc = R_HPPA_ABS_CALL;
5090                   the_insn.format = 17;
5091                   the_insn.arg_reloc = last_call_desc.arg_reloc;
5092                   memset (&last_call_desc, 0, sizeof (struct call_desc));
5093                   continue;
5094                 }
5095
5096             /* Handle '%r1' implicit operand of addil instruction.  */
5097             case 'Z':
5098               if (*s == ',' && *(s + 1) == '%' && *(s + 3) == '1'
5099                   && (*(s + 2) == 'r' || *(s + 2) == 'R'))
5100                 {
5101                   s += 4;
5102                   continue;
5103                 }
5104               else
5105                 break;
5106
5107             /* Handle '%sr0,%r31' implicit operand of be,l instruction.  */
5108             case 'Y':
5109               if (strncasecmp (s, "%sr0,%r31", 9) != 0)
5110                 break;
5111               s += 9;
5112               continue;
5113
5114             /* Handle immediate value of 0 for ordered load/store instructions.  */
5115             case '@':
5116               if (*s != '0')
5117                 break;
5118               s++;
5119               continue;
5120
5121             /* Handle a 2 bit shift count at 25.  */
5122             case '.':
5123               num = pa_get_absolute_expression (&the_insn, &s);
5124               if (strict && the_insn.exp.X_op != O_constant)
5125                 break;
5126               s = expr_end;
5127               CHECK_FIELD (num, 3, 1, strict);
5128               INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
5129
5130             /* Handle a 4 bit shift count at 25.  */
5131             case '*':
5132               num = pa_get_absolute_expression (&the_insn, &s);
5133               if (strict && the_insn.exp.X_op != O_constant)
5134                 break;
5135               s = expr_end;
5136               CHECK_FIELD (num, 15, 0, strict);
5137               INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
5138
5139             /* Handle a 5 bit shift count at 26.  */
5140             case 'p':
5141               num = pa_get_absolute_expression (&the_insn, &s);
5142               if (strict && the_insn.exp.X_op != O_constant)
5143                 break;
5144               s = expr_end;
5145               CHECK_FIELD (num, 31, 0, strict);
5146               SAVE_IMMEDIATE(num);
5147               INSERT_FIELD_AND_CONTINUE (opcode, 31 - num, 5);
5148
5149             /* Handle a 6 bit shift count at 20,22:26.  */
5150             case '~':
5151               num = pa_get_absolute_expression (&the_insn, &s);
5152               if (strict && the_insn.exp.X_op != O_constant)
5153                 break;
5154               s = expr_end;
5155               CHECK_FIELD (num, 63, 0, strict);
5156               SAVE_IMMEDIATE(num);
5157               num = 63 - num;
5158               opcode |= (num & 0x20) << 6;
5159               INSERT_FIELD_AND_CONTINUE (opcode, num & 0x1f, 5);
5160
5161             /* Handle a 6 bit field length at 23,27:31.  */
5162             case '%':
5163               flag = 0;
5164               num = pa_get_absolute_expression (&the_insn, &s);
5165               if (strict && the_insn.exp.X_op != O_constant)
5166                 break;
5167               s = expr_end;
5168               CHECK_FIELD (num, 64, 1, strict);
5169               SAVE_IMMEDIATE(num);
5170               num--;
5171               opcode |= (num & 0x20) << 3;
5172               num = 31 - (num & 0x1f);
5173               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5174
5175             /* Handle a 6 bit field length at 19,27:31.  */
5176             case '|':
5177               num = pa_get_absolute_expression (&the_insn, &s);
5178               if (strict && the_insn.exp.X_op != O_constant)
5179                 break;
5180               s = expr_end;
5181               CHECK_FIELD (num, 64, 1, strict);
5182               SAVE_IMMEDIATE(num);
5183               num--;
5184               opcode |= (num & 0x20) << 7;
5185               num = 31 - (num & 0x1f);
5186               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5187
5188             /* Handle a 5 bit bit position at 26.  */
5189             case 'P':
5190               num = pa_get_absolute_expression (&the_insn, &s);
5191               if (strict && the_insn.exp.X_op != O_constant)
5192                 break;
5193               s = expr_end;
5194               CHECK_FIELD (num, 31, 0, strict);
5195               SAVE_IMMEDIATE(num);
5196               INSERT_FIELD_AND_CONTINUE (opcode, num, 5);
5197
5198             /* Handle a 6 bit bit position at 20,22:26.  */
5199             case 'q':
5200               num = pa_get_absolute_expression (&the_insn, &s);
5201               if (strict && the_insn.exp.X_op != O_constant)
5202                 break;
5203               s = expr_end;
5204               CHECK_FIELD (num, 63, 0, strict);
5205               SAVE_IMMEDIATE(num);
5206               opcode |= (num & 0x20) << 6;
5207               INSERT_FIELD_AND_CONTINUE (opcode, num & 0x1f, 5);
5208
5209             /* Handle a 5 bit immediate at 10 with 'd' as the complement
5210                of the high bit of the immediate.  */
5211             case 'B':
5212               num = pa_get_absolute_expression (&the_insn, &s);
5213               if (strict && the_insn.exp.X_op != O_constant)
5214                 break;
5215               s = expr_end;
5216               CHECK_FIELD (num, 63, 0, strict);
5217               if (num & 0x20)
5218                 ;
5219               else
5220                 opcode |= (1 << 13);
5221               INSERT_FIELD_AND_CONTINUE (opcode, num & 0x1f, 21);
5222
5223             /* Handle a 5 bit immediate at 10.  */
5224             case 'Q':
5225               num = pa_get_absolute_expression (&the_insn, &s);
5226               if (strict && the_insn.exp.X_op != O_constant)
5227                 break;
5228               s = expr_end;
5229               CHECK_FIELD (num, 31, 0, strict);
5230               INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
5231
5232             /* Handle a 9 bit immediate at 28.  */
5233             case '$':
5234               num = pa_get_absolute_expression (&the_insn, &s);
5235               if (strict && the_insn.exp.X_op != O_constant)
5236                 break;
5237               s = expr_end;
5238               CHECK_FIELD (num, 511, 1, strict);
5239               INSERT_FIELD_AND_CONTINUE (opcode, num, 3);
5240
5241             /* Handle a 13 bit immediate at 18.  */
5242             case 'A':
5243               num = pa_get_absolute_expression (&the_insn, &s);
5244               if (strict && the_insn.exp.X_op != O_constant)
5245                 break;
5246               s = expr_end;
5247               CHECK_FIELD (num, 8191, 0, strict);
5248               INSERT_FIELD_AND_CONTINUE (opcode, num, 13);
5249
5250             /* Handle a 26 bit immediate at 31.  */
5251             case 'D':
5252               num = pa_get_absolute_expression (&the_insn, &s);
5253               if (strict && the_insn.exp.X_op != O_constant)
5254                 break;
5255               s = expr_end;
5256               CHECK_FIELD (num, 67108863, 0, strict);
5257               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5258
5259             /* Handle a 3 bit SFU identifier at 25.  */
5260             case 'v':
5261               if (*s++ != ',')
5262                 as_bad (_("Invalid SFU identifier"));
5263               num = pa_get_number (&the_insn, &s);
5264               if (strict && the_insn.exp.X_op != O_constant)
5265                 break;
5266               s = expr_end;
5267               CHECK_FIELD (num, 7, 0, strict);
5268               INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
5269
5270             /* Handle a 20 bit SOP field for spop0.  */
5271             case 'O':
5272               num = pa_get_number (&the_insn, &s);
5273               if (strict && the_insn.exp.X_op != O_constant)
5274                 break;
5275               s = expr_end;
5276               CHECK_FIELD (num, 1048575, 0, strict);
5277               num = (num & 0x1f) | ((num & 0x000fffe0) << 6);
5278               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5279
5280             /* Handle a 15bit SOP field for spop1.  */
5281             case 'o':
5282               num = pa_get_number (&the_insn, &s);
5283               if (strict && the_insn.exp.X_op != O_constant)
5284                 break;
5285               s = expr_end;
5286               CHECK_FIELD (num, 32767, 0, strict);
5287               INSERT_FIELD_AND_CONTINUE (opcode, num, 11);
5288
5289             /* Handle a 10bit SOP field for spop3.  */
5290             case '0':
5291               num = pa_get_number (&the_insn, &s);
5292               if (strict && the_insn.exp.X_op != O_constant)
5293                 break;
5294               s = expr_end;
5295               CHECK_FIELD (num, 1023, 0, strict);
5296               num = (num & 0x1f) | ((num & 0x000003e0) << 6);
5297               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5298
5299             /* Handle a 15 bit SOP field for spop2.  */
5300             case '1':
5301               num = pa_get_number (&the_insn, &s);
5302               if (strict && the_insn.exp.X_op != O_constant)
5303                 break;
5304               s = expr_end;
5305               CHECK_FIELD (num, 32767, 0, strict);
5306               num = (num & 0x1f) | ((num & 0x00007fe0) << 6);
5307               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5308
5309             /* Handle a 3-bit co-processor ID field.  */
5310             case 'u':
5311               if (*s++ != ',')
5312                 as_bad (_("Invalid COPR identifier"));
5313               num = pa_get_number (&the_insn, &s);
5314               if (strict && the_insn.exp.X_op != O_constant)
5315                 break;
5316               s = expr_end;
5317               CHECK_FIELD (num, 7, 0, strict);
5318               INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
5319
5320             /* Handle a 22bit SOP field for copr.  */
5321             case '2':
5322               num = pa_get_number (&the_insn, &s);
5323               if (strict && the_insn.exp.X_op != O_constant)
5324                 break;
5325               s = expr_end;
5326               CHECK_FIELD (num, 4194303, 0, strict);
5327               num = (num & 0x1f) | ((num & 0x003fffe0) << 4);
5328               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5329
5330             /* Handle a source FP operand format completer.  */
5331             case '{':
5332               if (*s == ',' && *(s+1) == 't')
5333                 {
5334                   the_insn.trunc = 1;
5335                   s += 2;
5336                 }
5337               else
5338                 the_insn.trunc = 0;
5339               flag = pa_parse_fp_cnv_format (&s);
5340               the_insn.fpof1 = flag;
5341               if (flag == W || flag == UW)
5342                 flag = SGL;
5343               if (flag == DW || flag == UDW)
5344                 flag = DBL;
5345               if (flag == QW || flag == UQW)
5346                 flag = QUAD;
5347               INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
5348
5349             /* Handle a destination FP operand format completer.  */
5350             case '_':
5351               /* pa_parse_format needs the ',' prefix.  */
5352               s--;
5353               flag = pa_parse_fp_cnv_format (&s);
5354               the_insn.fpof2 = flag;
5355               if (flag == W || flag == UW)
5356                 flag = SGL;
5357               if (flag == DW || flag == UDW)
5358                 flag = DBL;
5359               if (flag == QW || flag == UQW)
5360                 flag = QUAD;
5361               opcode |= flag << 13;
5362               if (the_insn.fpof1 == SGL
5363                   || the_insn.fpof1 == DBL
5364                   || the_insn.fpof1 == QUAD)
5365                 {
5366                   if (the_insn.fpof2 == SGL
5367                       || the_insn.fpof2 == DBL
5368                       || the_insn.fpof2 == QUAD)
5369                     flag = 0;
5370                   else if (the_insn.fpof2 == W
5371                       || the_insn.fpof2 == DW
5372                       || the_insn.fpof2 == QW)
5373                     flag = 2;
5374                   else if (the_insn.fpof2 == UW
5375                       || the_insn.fpof2 == UDW
5376                       || the_insn.fpof2 == UQW)
5377                     flag = 6;
5378                   else
5379                     abort ();
5380                 }
5381               else if (the_insn.fpof1 == W
5382                        || the_insn.fpof1 == DW
5383                        || the_insn.fpof1 == QW)
5384                 {
5385                   if (the_insn.fpof2 == SGL
5386                       || the_insn.fpof2 == DBL
5387                       || the_insn.fpof2 == QUAD)
5388                     flag = 1;
5389                   else
5390                     abort ();
5391                 }
5392               else if (the_insn.fpof1 == UW
5393                        || the_insn.fpof1 == UDW
5394                        || the_insn.fpof1 == UQW)
5395                 {
5396                   if (the_insn.fpof2 == SGL
5397                       || the_insn.fpof2 == DBL
5398                       || the_insn.fpof2 == QUAD)
5399                     flag = 5;
5400                   else
5401                     abort ();
5402                 }
5403               flag |= the_insn.trunc;
5404               INSERT_FIELD_AND_CONTINUE (opcode, flag, 15);
5405
5406             /* Handle a source FP operand format completer.  */
5407             case 'F':
5408               flag = pa_parse_fp_format (&s);
5409               the_insn.fpof1 = flag;
5410               INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
5411
5412             /* Handle a destination FP operand format completer.  */
5413             case 'G':
5414               /* pa_parse_format needs the ',' prefix.  */
5415               s--;
5416               flag = pa_parse_fp_format (&s);
5417               the_insn.fpof2 = flag;
5418               INSERT_FIELD_AND_CONTINUE (opcode, flag, 13);
5419
5420             /* Handle a source FP operand format completer at 20.  */
5421             case 'I':
5422               flag = pa_parse_fp_format (&s);
5423               the_insn.fpof1 = flag;
5424               INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
5425
5426             /* Handle a floating point operand format at 26.
5427                Only allows single and double precision.  */
5428             case 'H':
5429               flag = pa_parse_fp_format (&s);
5430               switch (flag)
5431                 {
5432                 case SGL:
5433                   opcode |= 0x20;
5434                 case DBL:
5435                   the_insn.fpof1 = flag;
5436                   continue;
5437
5438                 case QUAD:
5439                 case ILLEGAL_FMT:
5440                 default:
5441                   as_bad (_("Invalid Floating Point Operand Format."));
5442                 }
5443               break;
5444
5445             /* Handle all floating point registers.  */
5446             case 'f':
5447               switch (*++args)
5448                 {
5449                 /* Float target register.  */
5450                 case 't':
5451                   if (!pa_parse_number (&s, 3))
5452                     break;
5453                   /* RSEL should not be set.  */
5454                   if (pa_number & FP_REG_RSEL)
5455                     break;
5456                   num = pa_number - FP_REG_BASE;
5457                   CHECK_FIELD (num, 31, 0, 0);
5458                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5459
5460                 /* Float target register with L/R selection.  */
5461                 case 'T':
5462                   {
5463                     if (!pa_parse_number (&s, 1))
5464                       break;
5465                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5466                     CHECK_FIELD (num, 31, 0, 0);
5467                     opcode |= num;
5468
5469                     /* 0x30 opcodes are FP arithmetic operation opcodes
5470                        and need to be turned into 0x38 opcodes.  This
5471                        is not necessary for loads/stores.  */
5472                     if (need_pa11_opcode ()
5473                         && ((opcode & 0xfc000000) == 0x30000000))
5474                       opcode |= 1 << 27;
5475
5476                     opcode |= (pa_number & FP_REG_RSEL ? 1 << 6 : 0);
5477                     continue;
5478                   }
5479
5480                 /* Float operand 1.  */
5481                 case 'a':
5482                   {
5483                     if (!pa_parse_number (&s, 1))
5484                       break;
5485                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5486                     CHECK_FIELD (num, 31, 0, 0);
5487                     opcode |= num << 21;
5488                     if (need_pa11_opcode ())
5489                       {
5490                         opcode |= (pa_number & FP_REG_RSEL ? 1 << 7 : 0);
5491                         opcode |= 1 << 27;
5492                       }
5493                     continue;
5494                   }
5495
5496                 /* Float operand 1 with L/R selection.  */
5497                 case 'X':
5498                 case 'A':
5499                   {
5500                     if (!pa_parse_number (&s, 1))
5501                       break;
5502                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5503                     CHECK_FIELD (num, 31, 0, 0);
5504                     opcode |= num << 21;
5505                     opcode |= (pa_number & FP_REG_RSEL ? 1 << 7 : 0);
5506                     continue;
5507                   }
5508
5509                 /* Float operand 2.  */
5510                 case 'b':
5511                   {
5512                     if (!pa_parse_number (&s, 1))
5513                       break;
5514                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5515                     CHECK_FIELD (num, 31, 0, 0);
5516                     opcode |= num << 16;
5517                     if (need_pa11_opcode ())
5518                       {
5519                         opcode |= (pa_number & FP_REG_RSEL ? 1 << 12 : 0);
5520                         opcode |= 1 << 27;
5521                       }
5522                     continue;
5523                   }
5524
5525                 /* Float operand 2 with L/R selection.  */
5526                 case 'B':
5527                   {
5528                     if (!pa_parse_number (&s, 1))
5529                       break;
5530                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5531                     CHECK_FIELD (num, 31, 0, 0);
5532                     opcode |= num << 16;
5533                     opcode |= (pa_number & FP_REG_RSEL ? 1 << 12 : 0);
5534                     continue;
5535                   }
5536
5537                 /* Float operand 3 for fmpyfadd, fmpynfadd.  */
5538                 case 'C':
5539                   {
5540                     if (!pa_parse_number (&s, 1))
5541                       break;
5542                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5543                     CHECK_FIELD (num, 31, 0, 0);
5544                     opcode |= (num & 0x1c) << 11;
5545                     opcode |= (num & 0x03) << 9;
5546                     opcode |= (pa_number & FP_REG_RSEL ? 1 << 8 : 0);
5547                     continue;
5548                   }
5549
5550                 /* Float mult operand 1 for fmpyadd, fmpysub */
5551                 case 'i':
5552                   {
5553                     if (!pa_parse_number (&s, 1))
5554                       break;
5555                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5556                     CHECK_FIELD (num, 31, 0, 0);
5557                     if (the_insn.fpof1 == SGL)
5558                       {
5559                         if (num < 16)
5560                           {
5561                             as_bad  (_("Invalid register for single precision fmpyadd or fmpysub"));
5562                             break;
5563                           }
5564                         num &= 0xF;
5565                         num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
5566                       }
5567                     INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
5568                   }
5569
5570                 /* Float mult operand 2 for fmpyadd, fmpysub */
5571                 case 'j':
5572                   {
5573                     if (!pa_parse_number (&s, 1))
5574                       break;
5575                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5576                     CHECK_FIELD (num, 31, 0, 0);
5577                     if (the_insn.fpof1 == SGL)
5578                       {
5579                         if (num < 16)
5580                           {
5581                             as_bad  (_("Invalid register for single precision fmpyadd or fmpysub"));
5582                             break;
5583                           }
5584                         num &= 0xF;
5585                         num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
5586                       }
5587                     INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
5588                   }
5589
5590                 /* Float mult target for fmpyadd, fmpysub */
5591                 case 'k':
5592                   {
5593                     if (!pa_parse_number (&s, 1))
5594                       break;
5595                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5596                     CHECK_FIELD (num, 31, 0, 0);
5597                     if (the_insn.fpof1 == SGL)
5598                       {
5599                         if (num < 16)
5600                           {
5601                             as_bad  (_("Invalid register for single precision fmpyadd or fmpysub"));
5602                             break;
5603                           }
5604                         num &= 0xF;
5605                         num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
5606                       }
5607                     INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5608                   }
5609
5610                 /* Float add operand 1 for fmpyadd, fmpysub */
5611                 case 'l':
5612                   {
5613                     if (!pa_parse_number (&s, 1))
5614                       break;
5615                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5616                     CHECK_FIELD (num, 31, 0, 0);
5617                     if (the_insn.fpof1 == SGL)
5618                       {
5619                         if (num < 16)
5620                           {
5621                             as_bad  (_("Invalid register for single precision fmpyadd or fmpysub"));
5622                             break;
5623                           }
5624                         num &= 0xF;
5625                         num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
5626                       }
5627                     INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
5628                   }
5629
5630                 /* Float add target for fmpyadd, fmpysub */
5631                 case 'm':
5632                   {
5633                     if (!pa_parse_number (&s, 1))
5634                       break;
5635                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5636                     CHECK_FIELD (num, 31, 0, 0);
5637                     if (the_insn.fpof1 == SGL)
5638                       {
5639                         if (num < 16)
5640                           {
5641                             as_bad  (_("Invalid register for single precision fmpyadd or fmpysub"));
5642                             break;
5643                           }
5644                         num &= 0xF;
5645                         num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
5646                       }
5647                     INSERT_FIELD_AND_CONTINUE (opcode, num, 11);
5648                   }
5649
5650                 /* Handle L/R register halves like 'x'.  */
5651                 case 'E':
5652                 case 'e':
5653                   {
5654                     if (!pa_parse_number (&s, 1))
5655                       break;
5656                     num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5657                     CHECK_FIELD (num, 31, 0, 0);
5658                     opcode |= num << 16;
5659                     if (need_pa11_opcode ())
5660                       {
5661                         opcode |= (pa_number & FP_REG_RSEL ? 1 << 1 : 0);
5662                       }
5663                     continue;
5664                   }
5665
5666                 /* Float target register (PA 2.0 wide).  */
5667                 case 'x':
5668                   if (!pa_parse_number (&s, 3))
5669                     break;
5670                   num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5671                   CHECK_FIELD (num, 31, 0, 0);
5672                   INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
5673
5674                 default:
5675                   abort ();
5676                 }
5677               break;
5678
5679             default:
5680               abort ();
5681             }
5682           break;
5683         }
5684
5685       /* If this instruction is specific to a particular architecture,
5686          then set a new architecture.  This automatic promotion crud is
5687          for compatibility with HP's old assemblers only.  */
5688       if (match == TRUE
5689           && bfd_get_mach (stdoutput) < insn->arch
5690           && !bfd_set_arch_mach (stdoutput, bfd_arch_hppa, insn->arch))
5691         {
5692           as_warn (_("could not update architecture and machine"));
5693           match = FALSE;
5694         }
5695
5696  failed:
5697       /* Check if the args matched.  */
5698       if (!match)
5699         {
5700           if (&insn[1] - pa_opcodes < (int) NUMOPCODES
5701               && !strcmp (insn->name, insn[1].name))
5702             {
5703               ++insn;
5704               s = argstart;
5705               continue;
5706             }
5707           else
5708             {
5709               as_bad (_("Invalid operands %s"), error_message);
5710               return;
5711             }
5712         }
5713       break;
5714     }
5715
5716   if (immediate_check)
5717     {
5718       if (pos != -1 && len != -1 && pos < len - 1)
5719         as_warn (_("Immediates %d and %d will give undefined behavior."),
5720                         pos, len);
5721     }
5722
5723   the_insn.opcode = opcode;
5724 }
5725
5726 /* Assemble a single instruction storing it into a frag.  */
5727
5728 void
5729 md_assemble (char *str)
5730 {
5731   char *to;
5732
5733   /* The had better be something to assemble.  */
5734   gas_assert (str);
5735
5736   /* If we are within a procedure definition, make sure we've
5737      defined a label for the procedure; handle case where the
5738      label was defined after the .PROC directive.
5739
5740      Note there's not need to diddle with the segment or fragment
5741      for the label symbol in this case.  We have already switched
5742      into the new $CODE$ subspace at this point.  */
5743   if (within_procedure && last_call_info->start_symbol == NULL)
5744     {
5745       label_symbol_struct *label_symbol = pa_get_label ();
5746
5747       if (label_symbol)
5748         {
5749           if (label_symbol->lss_label)
5750             {
5751               last_call_info->start_symbol = label_symbol->lss_label;
5752               symbol_get_bfdsym (label_symbol->lss_label)->flags
5753                 |= BSF_FUNCTION;
5754 #ifdef OBJ_SOM
5755               /* Also handle allocation of a fixup to hold the unwind
5756                  information when the label appears after the proc/procend.  */
5757               if (within_entry_exit)
5758                 {
5759                   char *where;
5760                   unsigned int u;
5761
5762                   where = frag_more (0);
5763                   u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
5764                   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
5765                                 NULL, (offsetT) 0, NULL,
5766                                 0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
5767                 }
5768 #endif
5769             }
5770           else
5771             as_bad (_("Missing function name for .PROC (corrupted label chain)"));
5772         }
5773       else
5774         as_bad (_("Missing function name for .PROC"));
5775     }
5776
5777   /* Assemble the instruction.  Results are saved into "the_insn".  */
5778   pa_ip (str);
5779
5780   /* Get somewhere to put the assembled instruction.  */
5781   to = frag_more (4);
5782
5783   /* Output the opcode.  */
5784   md_number_to_chars (to, the_insn.opcode, 4);
5785
5786   /* If necessary output more stuff.  */
5787   if (the_insn.reloc != R_HPPA_NONE)
5788     fix_new_hppa (frag_now, (to - frag_now->fr_literal), 4, NULL,
5789                   (offsetT) 0, &the_insn.exp, the_insn.pcrel,
5790                   the_insn.reloc, the_insn.field_selector,
5791                   the_insn.format, the_insn.arg_reloc, 0);
5792
5793 #ifdef OBJ_ELF
5794   dwarf2_emit_insn (4);
5795 #endif
5796 }
5797
5798 #ifdef OBJ_SOM
5799 /* Handle an alignment directive.  Special so that we can update the
5800    alignment of the subspace if necessary.  */
5801 static void
5802 pa_align (int bytes)
5803 {
5804   /* We must have a valid space and subspace.  */
5805   pa_check_current_space_and_subspace ();
5806
5807   /* Let the generic gas code do most of the work.  */
5808   s_align_bytes (bytes);
5809
5810   /* If bytes is a power of 2, then update the current subspace's
5811      alignment if necessary.  */
5812   if (exact_log2 (bytes) != -1)
5813     record_alignment (current_subspace->ssd_seg, exact_log2 (bytes));
5814 }
5815 #endif
5816
5817 /* Handle a .BLOCK type pseudo-op.  */
5818
5819 static void
5820 pa_block (int z ATTRIBUTE_UNUSED)
5821 {
5822   unsigned int temp_size;
5823
5824 #ifdef OBJ_SOM
5825   /* We must have a valid space and subspace.  */
5826   pa_check_current_space_and_subspace ();
5827 #endif
5828
5829   temp_size = get_absolute_expression ();
5830
5831   if (temp_size > 0x3FFFFFFF)
5832     {
5833       as_bad (_("Argument to .BLOCK/.BLOCKZ must be between 0 and 0x3fffffff"));
5834       temp_size = 0;
5835     }
5836   else
5837     {
5838       /* Always fill with zeros, that's what the HP assembler does.  */
5839       char *p = frag_var (rs_fill, 1, 1, 0, NULL, temp_size, NULL);
5840       *p = 0;
5841     }
5842
5843   pa_undefine_label ();
5844   demand_empty_rest_of_line ();
5845 }
5846
5847 /* Handle a .begin_brtab and .end_brtab pseudo-op.  */
5848
5849 static void
5850 pa_brtab (int begin ATTRIBUTE_UNUSED)
5851 {
5852
5853 #ifdef OBJ_SOM
5854   /* The BRTAB relocations are only available in SOM (to denote
5855      the beginning and end of branch tables).  */
5856   char *where = frag_more (0);
5857
5858   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
5859                 NULL, (offsetT) 0, NULL,
5860                 0, begin ? R_HPPA_BEGIN_BRTAB : R_HPPA_END_BRTAB,
5861                 e_fsel, 0, 0, 0);
5862 #endif
5863
5864   demand_empty_rest_of_line ();
5865 }
5866
5867 /* Handle a .begin_try and .end_try pseudo-op.  */
5868
5869 static void
5870 pa_try (int begin ATTRIBUTE_UNUSED)
5871 {
5872 #ifdef OBJ_SOM
5873   expressionS exp;
5874   char *where = frag_more (0);
5875
5876   if (! begin)
5877     expression (&exp);
5878
5879   /* The TRY relocations are only available in SOM (to denote
5880      the beginning and end of exception handling regions).  */
5881
5882   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
5883                 NULL, (offsetT) 0, begin ? NULL : &exp,
5884                 0, begin ? R_HPPA_BEGIN_TRY : R_HPPA_END_TRY,
5885                 e_fsel, 0, 0, 0);
5886 #endif
5887
5888   demand_empty_rest_of_line ();
5889 }
5890
5891 /* Do the dirty work of building a call descriptor which describes
5892    where the caller placed arguments to a function call.  */
5893
5894 static void
5895 pa_call_args (struct call_desc *call_desc)
5896 {
5897   char *name, c;
5898   unsigned int temp, arg_reloc;
5899
5900   while (!is_end_of_statement ())
5901     {
5902       c = get_symbol_name (&name);
5903       /* Process a source argument.  */
5904       if ((strncasecmp (name, "argw", 4) == 0))
5905         {
5906           temp = atoi (name + 4);
5907           (void) restore_line_pointer (c);
5908           input_line_pointer++;
5909           c = get_symbol_name (&name);
5910           arg_reloc = pa_build_arg_reloc (name);
5911           call_desc->arg_reloc |= pa_align_arg_reloc (temp, arg_reloc);
5912         }
5913       /* Process a return value.  */
5914       else if ((strncasecmp (name, "rtnval", 6) == 0))
5915         {
5916           (void) restore_line_pointer (c);
5917           input_line_pointer++;
5918           c = get_symbol_name (&name);
5919           arg_reloc = pa_build_arg_reloc (name);
5920           call_desc->arg_reloc |= (arg_reloc & 0x3);
5921         }
5922       else
5923         {
5924           as_bad (_("Invalid .CALL argument: %s"), name);
5925         }
5926
5927       (void) restore_line_pointer (c);
5928       if (!is_end_of_statement ())
5929         input_line_pointer++;
5930     }
5931 }
5932
5933 /* Handle a .CALL pseudo-op.  This involves storing away information
5934    about where arguments are to be found so the linker can detect
5935    (and correct) argument location mismatches between caller and callee.  */
5936
5937 static void
5938 pa_call (int unused ATTRIBUTE_UNUSED)
5939 {
5940 #ifdef OBJ_SOM
5941   /* We must have a valid space and subspace.  */
5942   pa_check_current_space_and_subspace ();
5943 #endif
5944
5945   pa_call_args (&last_call_desc);
5946   demand_empty_rest_of_line ();
5947 }
5948
5949 #ifdef OBJ_ELF
5950 /* Build an entry in the UNWIND subspace from the given function
5951    attributes in CALL_INFO.  This is not needed for SOM as using
5952    R_ENTRY and R_EXIT relocations allow the linker to handle building
5953    of the unwind spaces.  */
5954
5955 static void
5956 pa_build_unwind_subspace (struct call_info *call_info)
5957 {
5958   asection *seg, *save_seg;
5959   subsegT save_subseg;
5960   unsigned int unwind;
5961   int reloc;
5962   char *name, *p;
5963   symbolS *symbolP;
5964
5965   if ((bfd_get_section_flags (stdoutput, now_seg)
5966        & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
5967       != (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
5968     return;
5969
5970   if (call_info->start_symbol == NULL)
5971     /* This can happen if there were errors earlier on in the assembly.  */
5972     return;
5973
5974   /* Replace the start symbol with a local symbol that will be reduced
5975      to a section offset.  This avoids problems with weak functions with
5976      multiple definitions, etc.  */
5977   name = xmalloc (strlen ("L$\001start_")
5978                   + strlen (S_GET_NAME (call_info->start_symbol))
5979                   + 1);
5980   strcpy (name, "L$\001start_");
5981   strcat (name, S_GET_NAME (call_info->start_symbol));
5982
5983   /* If we have a .procend preceded by a .exit, then the symbol will have
5984      already been defined.  In that case, we don't want another unwind
5985      entry.  */
5986   symbolP = symbol_find (name);
5987   if (symbolP)
5988     {
5989       xfree (name);
5990       return;
5991     }
5992   else
5993     {
5994       symbolP = symbol_new (name, now_seg,
5995                             S_GET_VALUE (call_info->start_symbol), frag_now);
5996       gas_assert (symbolP);
5997       S_CLEAR_EXTERNAL (symbolP);
5998       symbol_table_insert (symbolP);
5999     }
6000
6001   reloc = R_PARISC_SEGREL32;
6002   save_seg = now_seg;
6003   save_subseg = now_subseg;
6004   /* Get into the right seg/subseg.  This may involve creating
6005      the seg the first time through.  Make sure to have the
6006      old seg/subseg so that we can reset things when we are done.  */
6007   seg = bfd_get_section_by_name (stdoutput, UNWIND_SECTION_NAME);
6008   if (seg == ASEC_NULL)
6009     {
6010       seg = subseg_new (UNWIND_SECTION_NAME, 0);
6011       bfd_set_section_flags (stdoutput, seg,
6012                              SEC_READONLY | SEC_HAS_CONTENTS
6013                              | SEC_LOAD | SEC_RELOC | SEC_ALLOC | SEC_DATA);
6014       bfd_set_section_alignment (stdoutput, seg, 2);
6015     }
6016
6017   subseg_set (seg, 0);
6018
6019   /* Get some space to hold relocation information for the unwind
6020      descriptor.  */
6021   p = frag_more (16);
6022
6023   /* Relocation info. for start offset of the function.  */
6024   md_number_to_chars (p, 0, 4);
6025   fix_new_hppa (frag_now, p - frag_now->fr_literal, 4,
6026                 symbolP, (offsetT) 0,
6027                 (expressionS *) NULL, 0, reloc,
6028                 e_fsel, 32, 0, 0);
6029
6030   /* Relocation info. for end offset of the function.
6031
6032      Because we allow reductions of 32bit relocations for ELF, this will be
6033      reduced to section_sym + offset which avoids putting the temporary
6034      symbol into the symbol table.  It (should) end up giving the same
6035      value as call_info->start_symbol + function size once the linker is
6036      finished with its work.  */
6037   md_number_to_chars (p + 4, 0, 4);
6038   fix_new_hppa (frag_now, p + 4 - frag_now->fr_literal, 4,
6039                 call_info->end_symbol, (offsetT) 0,
6040                 (expressionS *) NULL, 0, reloc,
6041                 e_fsel, 32, 0, 0);
6042
6043   /* Dump the descriptor.  */
6044   unwind = UNWIND_LOW32 (&call_info->ci_unwind.descriptor);
6045   md_number_to_chars (p + 8, unwind, 4);
6046
6047   unwind = UNWIND_HIGH32 (&call_info->ci_unwind.descriptor);
6048   md_number_to_chars (p + 12, unwind, 4);
6049
6050   /* Return back to the original segment/subsegment.  */
6051   subseg_set (save_seg, save_subseg);
6052 }
6053 #endif
6054
6055 /* Process a .CALLINFO pseudo-op.  This information is used later
6056    to build unwind descriptors and maybe one day to support
6057    .ENTER and .LEAVE.  */
6058
6059 static void
6060 pa_callinfo (int unused ATTRIBUTE_UNUSED)
6061 {
6062   char *name, c;
6063   int temp;
6064
6065 #ifdef OBJ_SOM
6066   /* We must have a valid space and subspace.  */
6067   pa_check_current_space_and_subspace ();
6068 #endif
6069
6070   /* .CALLINFO must appear within a procedure definition.  */
6071   if (!within_procedure)
6072     as_bad (_(".callinfo is not within a procedure definition"));
6073
6074   /* Mark the fact that we found the .CALLINFO for the
6075      current procedure.  */
6076   callinfo_found = TRUE;
6077
6078   /* Iterate over the .CALLINFO arguments.  */
6079   while (!is_end_of_statement ())
6080     {
6081       c = get_symbol_name (&name);
6082       /* Frame size specification.  */
6083       if ((strncasecmp (name, "frame", 5) == 0))
6084         {
6085           (void) restore_line_pointer (c);
6086           input_line_pointer++;
6087           temp = get_absolute_expression ();
6088           if ((temp & 0x3) != 0)
6089             {
6090               as_bad (_("FRAME parameter must be a multiple of 8: %d\n"), temp);
6091               temp = 0;
6092             }
6093
6094           /* callinfo is in bytes and unwind_desc is in 8 byte units.  */
6095           last_call_info->ci_unwind.descriptor.frame_size = temp / 8;
6096         }
6097       /* Entry register (GR, GR and SR) specifications.  */
6098       else if ((strncasecmp (name, "entry_gr", 8) == 0))
6099         {
6100           (void) restore_line_pointer (c);
6101           input_line_pointer++;
6102           temp = get_absolute_expression ();
6103           /* The HP assembler accepts 19 as the high bound for ENTRY_GR
6104              even though %r19 is caller saved.  I think this is a bug in
6105              the HP assembler, and we are not going to emulate it.  */
6106           if (temp < 3 || temp > 18)
6107             as_bad (_("Value for ENTRY_GR must be in the range 3..18\n"));
6108           last_call_info->ci_unwind.descriptor.entry_gr = temp - 2;
6109         }
6110       else if ((strncasecmp (name, "entry_fr", 8) == 0))
6111         {
6112           (void) restore_line_pointer (c);
6113           input_line_pointer++;
6114           temp = get_absolute_expression ();
6115           /* Similarly the HP assembler takes 31 as the high bound even
6116              though %fr21 is the last callee saved floating point register.  */
6117           if (temp < 12 || temp > 21)
6118             as_bad (_("Value for ENTRY_FR must be in the range 12..21\n"));
6119           last_call_info->ci_unwind.descriptor.entry_fr = temp - 11;
6120         }
6121       else if ((strncasecmp (name, "entry_sr", 8) == 0))
6122         {
6123           (void) restore_line_pointer (c);
6124           input_line_pointer++;
6125           temp = get_absolute_expression ();
6126           if (temp != 3)
6127             as_bad (_("Value for ENTRY_SR must be 3\n"));
6128         }
6129       /* Note whether or not this function performs any calls.  */
6130       else if ((strncasecmp (name, "calls", 5) == 0)
6131                || (strncasecmp (name, "caller", 6) == 0))
6132         {
6133           (void) restore_line_pointer (c);
6134         }
6135       else if ((strncasecmp (name, "no_calls", 8) == 0))
6136         {
6137           (void) restore_line_pointer (c);
6138         }
6139       /* Should RP be saved into the stack.  */
6140       else if ((strncasecmp (name, "save_rp", 7) == 0))
6141         {
6142           (void) restore_line_pointer (c);
6143           last_call_info->ci_unwind.descriptor.save_rp = 1;
6144         }
6145       /* Likewise for SP.  */
6146       else if ((strncasecmp (name, "save_sp", 7) == 0))
6147         {
6148           (void) restore_line_pointer (c);
6149           last_call_info->ci_unwind.descriptor.save_sp = 1;
6150         }
6151       /* Is this an unwindable procedure.  If so mark it so
6152          in the unwind descriptor.  */
6153       else if ((strncasecmp (name, "no_unwind", 9) == 0))
6154         {
6155           (void) restore_line_pointer (c);
6156           last_call_info->ci_unwind.descriptor.cannot_unwind = 1;
6157         }
6158       /* Is this an interrupt routine.  If so mark it in the
6159          unwind descriptor.  */
6160       else if ((strncasecmp (name, "hpux_int", 7) == 0))
6161         {
6162           (void) restore_line_pointer (c);
6163           last_call_info->ci_unwind.descriptor.hpux_interrupt_marker = 1;
6164         }
6165       /* Is this a millicode routine.  "millicode" isn't in my
6166          assembler manual, but my copy is old.  The HP assembler
6167          accepts it, and there's a place in the unwind descriptor
6168          to drop the information, so we'll accept it too.  */
6169       else if ((strncasecmp (name, "millicode", 9) == 0))
6170         {
6171           (void) restore_line_pointer (c);
6172           last_call_info->ci_unwind.descriptor.millicode = 1;
6173         }
6174       else
6175         {
6176           as_bad (_("Invalid .CALLINFO argument: %s"), name);
6177           (void) restore_line_pointer (c);
6178         }
6179
6180       if (!is_end_of_statement ())
6181         input_line_pointer++;
6182     }
6183
6184   demand_empty_rest_of_line ();
6185 }
6186
6187 #if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
6188 /* Switch to the text space.  Like s_text, but delete our
6189    label when finished.  */
6190
6191 static void
6192 pa_text (int unused ATTRIBUTE_UNUSED)
6193 {
6194 #ifdef OBJ_SOM
6195   current_space = is_defined_space ("$TEXT$");
6196   current_subspace
6197     = pa_subsegment_to_subspace (current_space->sd_seg, 0);
6198 #endif
6199
6200   s_text (0);
6201   pa_undefine_label ();
6202 }
6203
6204 /* Switch to the data space.  As usual delete our label.  */
6205
6206 static void
6207 pa_data (int unused ATTRIBUTE_UNUSED)
6208 {
6209 #ifdef OBJ_SOM
6210   current_space = is_defined_space ("$PRIVATE$");
6211   current_subspace
6212     = pa_subsegment_to_subspace (current_space->sd_seg, 0);
6213 #endif
6214   s_data (0);
6215   pa_undefine_label ();
6216 }
6217
6218 /* This is different than the standard GAS s_comm(). On HP9000/800 machines,
6219    the .comm pseudo-op has the following syntax:
6220
6221    <label> .comm <length>
6222
6223    where <label> is optional and is a symbol whose address will be the start of
6224    a block of memory <length> bytes long. <length> must be an absolute
6225    expression.  <length> bytes will be allocated in the current space
6226    and subspace.
6227
6228    Also note the label may not even be on the same line as the .comm.
6229
6230    This difference in syntax means the colon function will be called
6231    on the symbol before we arrive in pa_comm.  colon will set a number
6232    of attributes of the symbol that need to be fixed here.  In particular
6233    the value, section pointer, fragment pointer, flags, etc.  What
6234    a pain.
6235
6236    This also makes error detection all but impossible.  */
6237
6238 static void
6239 pa_comm (int unused ATTRIBUTE_UNUSED)
6240 {
6241   unsigned int size;
6242   symbolS *symbol;
6243   label_symbol_struct *label_symbol = pa_get_label ();
6244
6245   if (label_symbol)
6246     symbol = label_symbol->lss_label;
6247   else
6248     symbol = NULL;
6249
6250   SKIP_WHITESPACE ();
6251   size = get_absolute_expression ();
6252
6253   if (symbol)
6254     {
6255       symbol_get_bfdsym (symbol)->flags |= BSF_OBJECT;
6256       S_SET_VALUE (symbol, size);
6257       S_SET_SEGMENT (symbol, bfd_com_section_ptr);
6258       S_SET_EXTERNAL (symbol);
6259
6260       /* colon() has already set the frag to the current location in the
6261          current subspace; we need to reset the fragment to the zero address
6262          fragment.  We also need to reset the segment pointer.  */
6263       symbol_set_frag (symbol, &zero_address_frag);
6264     }
6265   demand_empty_rest_of_line ();
6266 }
6267 #endif /* !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD))) */
6268
6269 /* Process a .END pseudo-op.  */
6270
6271 static void
6272 pa_end (int unused ATTRIBUTE_UNUSED)
6273 {
6274   demand_empty_rest_of_line ();
6275 }
6276
6277 /* Process a .ENTER pseudo-op.  This is not supported.  */
6278
6279 static void
6280 pa_enter (int unused ATTRIBUTE_UNUSED)
6281 {
6282 #ifdef OBJ_SOM
6283   /* We must have a valid space and subspace.  */
6284   pa_check_current_space_and_subspace ();
6285 #endif
6286
6287   as_bad (_("The .ENTER pseudo-op is not supported"));
6288   demand_empty_rest_of_line ();
6289 }
6290
6291 /* Process a .ENTRY pseudo-op.  .ENTRY marks the beginning of the
6292    procedure.  */
6293
6294 static void
6295 pa_entry (int unused ATTRIBUTE_UNUSED)
6296 {
6297 #ifdef OBJ_SOM
6298   /* We must have a valid space and subspace.  */
6299   pa_check_current_space_and_subspace ();
6300 #endif
6301
6302   if (!within_procedure)
6303     as_bad (_("Misplaced .entry. Ignored."));
6304   else
6305     {
6306       if (!callinfo_found)
6307         as_bad (_("Missing .callinfo."));
6308     }
6309   demand_empty_rest_of_line ();
6310   within_entry_exit = TRUE;
6311
6312 #ifdef OBJ_SOM
6313   /* SOM defers building of unwind descriptors until the link phase.
6314      The assembler is responsible for creating an R_ENTRY relocation
6315      to mark the beginning of a region and hold the unwind bits, and
6316      for creating an R_EXIT relocation to mark the end of the region.
6317
6318      FIXME.  ELF should be using the same conventions!  The problem
6319      is an unwind requires too much relocation space.  Hmmm.  Maybe
6320      if we split the unwind bits up between the relocations which
6321      denote the entry and exit points.  */
6322   if (last_call_info->start_symbol != NULL)
6323     {
6324       char *where;
6325       unsigned int u;
6326
6327       where = frag_more (0);
6328       u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
6329       fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6330                     NULL, (offsetT) 0, NULL,
6331                     0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
6332     }
6333 #endif
6334 }
6335
6336 /* Silly nonsense for pa_equ.  The only half-sensible use for this is
6337    being able to subtract two register symbols that specify a range of
6338    registers, to get the size of the range.  */
6339 static int fudge_reg_expressions;
6340
6341 int
6342 hppa_force_reg_syms_absolute (expressionS *resultP,
6343                               operatorT op ATTRIBUTE_UNUSED,
6344                               expressionS *rightP)
6345 {
6346   if (fudge_reg_expressions
6347       && rightP->X_op == O_register
6348       && resultP->X_op == O_register)
6349     {
6350       rightP->X_op = O_constant;
6351       resultP->X_op = O_constant;
6352     }
6353   return 0;  /* Continue normal expr handling.  */
6354 }
6355
6356 /* Handle a .EQU pseudo-op.  */
6357
6358 static void
6359 pa_equ (int reg)
6360 {
6361   label_symbol_struct *label_symbol = pa_get_label ();
6362   symbolS *symbol;
6363
6364   if (label_symbol)
6365     {
6366       symbol = label_symbol->lss_label;
6367       if (reg)
6368         {
6369           strict = 1;
6370           if (!pa_parse_number (&input_line_pointer, 0))
6371             as_bad (_(".REG expression must be a register"));
6372           S_SET_VALUE (symbol, pa_number);
6373           S_SET_SEGMENT (symbol, reg_section);
6374         }
6375       else
6376         {
6377           expressionS exp;
6378           segT seg;
6379
6380           fudge_reg_expressions = 1;
6381           seg = expression (&exp);
6382           fudge_reg_expressions = 0;
6383           if (exp.X_op != O_constant
6384               && exp.X_op != O_register)
6385             {
6386               if (exp.X_op != O_absent)
6387                 as_bad (_("bad or irreducible absolute expression; zero assumed"));
6388               exp.X_add_number = 0;
6389               seg = absolute_section;
6390             }
6391           S_SET_VALUE (symbol, (unsigned int) exp.X_add_number);
6392           S_SET_SEGMENT (symbol, seg);
6393         }
6394     }
6395   else
6396     {
6397       if (reg)
6398         as_bad (_(".REG must use a label"));
6399       else
6400         as_bad (_(".EQU must use a label"));
6401     }
6402
6403   pa_undefine_label ();
6404   demand_empty_rest_of_line ();
6405 }
6406
6407 #ifdef OBJ_ELF
6408 /* Mark the end of a function so that it's possible to compute
6409    the size of the function in elf_hppa_final_processing.  */
6410
6411 static void
6412 hppa_elf_mark_end_of_function (void)
6413 {
6414   /* ELF does not have EXIT relocations.  All we do is create a
6415      temporary symbol marking the end of the function.  */
6416   char *name;
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 = xmalloc (strlen ("L$\001end_")
6426                   + strlen (S_GET_NAME (last_call_info->start_symbol))
6427                   + 1);
6428   if (name)
6429     {
6430       symbolS *symbolP;
6431
6432       strcpy (name, "L$\001end_");
6433       strcat (name, S_GET_NAME (last_call_info->start_symbol));
6434
6435       /* If we have a .exit followed by a .procend, then the
6436          symbol will have already been defined.  */
6437       symbolP = symbol_find (name);
6438       if (symbolP)
6439         {
6440           /* The symbol has already been defined!  This can
6441              happen if we have a .exit followed by a .procend.
6442
6443              This is *not* an error.  All we want to do is free
6444              the memory we just allocated for the name and continue.  */
6445           xfree (name);
6446         }
6447       else
6448         {
6449           /* symbol value should be the offset of the
6450              last instruction of the function */
6451           symbolP = symbol_new (name, now_seg, (valueT) (frag_now_fix () - 4),
6452                                 frag_now);
6453
6454           gas_assert (symbolP);
6455           S_CLEAR_EXTERNAL (symbolP);
6456           symbol_table_insert (symbolP);
6457         }
6458
6459       if (symbolP)
6460         last_call_info->end_symbol = symbolP;
6461       else
6462         as_bad (_("Symbol '%s' could not be created."), name);
6463
6464     }
6465   else
6466     as_bad (_("No memory for symbol name."));
6467 }
6468 #endif
6469
6470 /* Helper function.  Does processing for the end of a function.  This
6471    usually involves creating some relocations or building special
6472    symbols to mark the end of the function.  */
6473
6474 static void
6475 process_exit (void)
6476 {
6477   char *where;
6478
6479   where = frag_more (0);
6480
6481 #ifdef OBJ_ELF
6482   /* Mark the end of the function, stuff away the location of the frag
6483      for the end of the function, and finally call pa_build_unwind_subspace
6484      to add an entry in the unwind table.  */
6485   (void) where;
6486   hppa_elf_mark_end_of_function ();
6487   pa_build_unwind_subspace (last_call_info);
6488 #else
6489   /* SOM defers building of unwind descriptors until the link phase.
6490      The assembler is responsible for creating an R_ENTRY relocation
6491      to mark the beginning of a region and hold the unwind bits, and
6492      for creating an R_EXIT relocation to mark the end of the region.
6493
6494      FIXME.  ELF should be using the same conventions!  The problem
6495      is an unwind requires too much relocation space.  Hmmm.  Maybe
6496      if we split the unwind bits up between the relocations which
6497      denote the entry and exit points.  */
6498   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6499                 NULL, (offsetT) 0,
6500                 NULL, 0, R_HPPA_EXIT, e_fsel, 0, 0,
6501                 UNWIND_HIGH32 (&last_call_info->ci_unwind.descriptor));
6502 #endif
6503 }
6504
6505 /* Process a .EXIT pseudo-op.  */
6506
6507 static void
6508 pa_exit (int unused ATTRIBUTE_UNUSED)
6509 {
6510 #ifdef OBJ_SOM
6511   /* We must have a valid space and subspace.  */
6512   pa_check_current_space_and_subspace ();
6513 #endif
6514
6515   if (!within_procedure)
6516     as_bad (_(".EXIT must appear within a procedure"));
6517   else
6518     {
6519       if (!callinfo_found)
6520         as_bad (_("Missing .callinfo"));
6521       else
6522         {
6523           if (!within_entry_exit)
6524             as_bad (_("No .ENTRY for this .EXIT"));
6525           else
6526             {
6527               within_entry_exit = FALSE;
6528               process_exit ();
6529             }
6530         }
6531     }
6532   demand_empty_rest_of_line ();
6533 }
6534
6535 /* Helper function to process arguments to a .EXPORT pseudo-op.  */
6536
6537 static void
6538 pa_type_args (symbolS *symbolP, int is_export)
6539 {
6540   char *name, c;
6541   unsigned int temp, arg_reloc;
6542   pa_symbol_type type = SYMBOL_TYPE_UNKNOWN;
6543   asymbol *bfdsym = symbol_get_bfdsym (symbolP);
6544
6545   if (strncasecmp (input_line_pointer, "absolute", 8) == 0)
6546     {
6547       input_line_pointer += 8;
6548       bfdsym->flags &= ~BSF_FUNCTION;
6549       S_SET_SEGMENT (symbolP, bfd_abs_section_ptr);
6550       type = SYMBOL_TYPE_ABSOLUTE;
6551     }
6552   else if (strncasecmp (input_line_pointer, "code", 4) == 0)
6553     {
6554       input_line_pointer += 4;
6555       /* IMPORTing/EXPORTing CODE types for functions is meaningless for SOM,
6556          instead one should be IMPORTing/EXPORTing ENTRY types.
6557
6558          Complain if one tries to EXPORT a CODE type since that's never
6559          done.  Both GCC and HP C still try to IMPORT CODE types, so
6560          silently fix them to be ENTRY types.  */
6561       if (S_IS_FUNCTION (symbolP))
6562         {
6563           if (is_export)
6564             as_tsktsk (_("Using ENTRY rather than CODE in export directive for %s"),
6565                        S_GET_NAME (symbolP));
6566
6567           bfdsym->flags |= BSF_FUNCTION;
6568           type = SYMBOL_TYPE_ENTRY;
6569         }
6570       else
6571         {
6572           bfdsym->flags &= ~BSF_FUNCTION;
6573           type = SYMBOL_TYPE_CODE;
6574         }
6575     }
6576   else if (strncasecmp (input_line_pointer, "data", 4) == 0)
6577     {
6578       input_line_pointer += 4;
6579       bfdsym->flags &= ~BSF_FUNCTION;
6580       bfdsym->flags |= BSF_OBJECT;
6581       type = SYMBOL_TYPE_DATA;
6582     }
6583   else if ((strncasecmp (input_line_pointer, "entry", 5) == 0))
6584     {
6585       input_line_pointer += 5;
6586       bfdsym->flags |= BSF_FUNCTION;
6587       type = SYMBOL_TYPE_ENTRY;
6588     }
6589   else if (strncasecmp (input_line_pointer, "millicode", 9) == 0)
6590     {
6591       input_line_pointer += 9;
6592       bfdsym->flags |= BSF_FUNCTION;
6593 #ifdef OBJ_ELF
6594       {
6595         elf_symbol_type *elfsym = (elf_symbol_type *) bfdsym;
6596         elfsym->internal_elf_sym.st_info =
6597           ELF_ST_INFO (ELF_ST_BIND (elfsym->internal_elf_sym.st_info),
6598                        STT_PARISC_MILLI);
6599       }
6600 #endif
6601       type = SYMBOL_TYPE_MILLICODE;
6602     }
6603   else if (strncasecmp (input_line_pointer, "plabel", 6) == 0)
6604     {
6605       input_line_pointer += 6;
6606       bfdsym->flags &= ~BSF_FUNCTION;
6607       type = SYMBOL_TYPE_PLABEL;
6608     }
6609   else if (strncasecmp (input_line_pointer, "pri_prog", 8) == 0)
6610     {
6611       input_line_pointer += 8;
6612       bfdsym->flags |= BSF_FUNCTION;
6613       type = SYMBOL_TYPE_PRI_PROG;
6614     }
6615   else if (strncasecmp (input_line_pointer, "sec_prog", 8) == 0)
6616     {
6617       input_line_pointer += 8;
6618       bfdsym->flags |= BSF_FUNCTION;
6619       type = SYMBOL_TYPE_SEC_PROG;
6620     }
6621
6622   /* SOM requires much more information about symbol types
6623      than BFD understands.  This is how we get this information
6624      to the SOM BFD backend.  */
6625 #ifdef obj_set_symbol_type
6626   obj_set_symbol_type (bfdsym, (int) type);
6627 #else
6628   (void) type;
6629 #endif
6630
6631   /* Now that the type of the exported symbol has been handled,
6632      handle any argument relocation information.  */
6633   while (!is_end_of_statement ())
6634     {
6635       if (*input_line_pointer == ',')
6636         input_line_pointer++;
6637       c = get_symbol_name (&name);
6638       /* Argument sources.  */
6639       if ((strncasecmp (name, "argw", 4) == 0))
6640         {
6641           (void) restore_line_pointer (c);
6642           input_line_pointer++;
6643           temp = atoi (name + 4);
6644           c = get_symbol_name (&name);
6645           arg_reloc = pa_align_arg_reloc (temp, pa_build_arg_reloc (name));
6646 #if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
6647           symbol_arg_reloc_info (symbolP) |= arg_reloc;
6648 #else
6649           (void) arg_reloc;
6650 #endif
6651           (void) restore_line_pointer (c);
6652         }
6653       /* The return value.  */
6654       else if ((strncasecmp (name, "rtnval", 6)) == 0)
6655         {
6656           (void) restore_line_pointer (c);
6657           input_line_pointer++;
6658           c = get_symbol_name (&name);
6659           arg_reloc = pa_build_arg_reloc (name);
6660 #if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
6661           symbol_arg_reloc_info (symbolP) |= arg_reloc;
6662 #else
6663           (void) arg_reloc;
6664 #endif
6665           (void) restore_line_pointer (c);
6666         }
6667       /* Privilege level.  */
6668       else if ((strncasecmp (name, "priv_lev", 8)) == 0)
6669         {
6670           char *priv;
6671
6672           (void) restore_line_pointer (c);
6673           input_line_pointer++;
6674           temp = atoi (input_line_pointer);
6675 #ifdef OBJ_SOM
6676           ((obj_symbol_type *) bfdsym)->tc_data.ap.hppa_priv_level = temp;
6677 #endif
6678           c = get_symbol_name (&priv);
6679           (void) restore_line_pointer (c);
6680         }
6681       else
6682         {
6683           as_bad (_("Undefined .EXPORT/.IMPORT argument (ignored): %s"), name);
6684           (void) restore_line_pointer (c);
6685         }
6686
6687       if (!is_end_of_statement ())
6688         input_line_pointer++;
6689     }
6690 }
6691
6692 /* Process a .EXPORT directive.  This makes functions external
6693    and provides information such as argument relocation entries
6694    to callers.  */
6695
6696 static void
6697 pa_export (int unused ATTRIBUTE_UNUSED)
6698 {
6699   char *name, c;
6700   symbolS *symbol;
6701
6702   c = get_symbol_name (&name);
6703   /* Make sure the given symbol exists.  */
6704   if ((symbol = symbol_find_or_make (name)) == NULL)
6705     {
6706       as_bad (_("Cannot define export symbol: %s\n"), name);
6707       restore_line_pointer (c);
6708       input_line_pointer++;
6709     }
6710   else
6711     {
6712       /* OK.  Set the external bits and process argument relocations.
6713          For the HP, weak and global are not mutually exclusive.
6714          S_SET_EXTERNAL will not set BSF_GLOBAL if WEAK is set.
6715          Call S_SET_EXTERNAL to get the other processing.  Manually
6716          set BSF_GLOBAL when we get back.  */
6717       S_SET_EXTERNAL (symbol);
6718       symbol_get_bfdsym (symbol)->flags |= BSF_GLOBAL;
6719       (void) restore_line_pointer (c);
6720       if (!is_end_of_statement ())
6721         {
6722           input_line_pointer++;
6723           pa_type_args (symbol, 1);
6724         }
6725     }
6726
6727   demand_empty_rest_of_line ();
6728 }
6729
6730 /* Handle an .IMPORT pseudo-op.  Any symbol referenced in a given
6731    assembly file must either be defined in the assembly file, or
6732    explicitly IMPORTED from another.  */
6733
6734 static void
6735 pa_import (int unused ATTRIBUTE_UNUSED)
6736 {
6737   char *name, c;
6738   symbolS *symbol;
6739
6740   c = get_symbol_name (&name);
6741
6742   symbol = symbol_find (name);
6743   /* Ugh.  We might be importing a symbol defined earlier in the file,
6744      in which case all the code below will really screw things up
6745      (set the wrong segment, symbol flags & type, etc).  */
6746   if (symbol == NULL || !S_IS_DEFINED (symbol))
6747     {
6748       symbol = symbol_find_or_make (name);
6749       (void) restore_line_pointer (c);
6750
6751       if (!is_end_of_statement ())
6752         {
6753           input_line_pointer++;
6754           pa_type_args (symbol, 0);
6755         }
6756       else
6757         {
6758           /* Sigh.  To be compatible with the HP assembler and to help
6759              poorly written assembly code, we assign a type based on
6760              the current segment.  Note only BSF_FUNCTION really
6761              matters, we do not need to set the full SYMBOL_TYPE_* info.  */
6762           if (now_seg == text_section)
6763             symbol_get_bfdsym (symbol)->flags |= BSF_FUNCTION;
6764
6765           /* If the section is undefined, then the symbol is undefined
6766              Since this is an import, leave the section undefined.  */
6767           S_SET_SEGMENT (symbol, bfd_und_section_ptr);
6768         }
6769     }
6770   else
6771     {
6772       /* The symbol was already defined.  Just eat everything up to
6773          the end of the current statement.  */
6774       while (!is_end_of_statement ())
6775         input_line_pointer++;
6776     }
6777
6778   demand_empty_rest_of_line ();
6779 }
6780
6781 /* Handle a .LABEL pseudo-op.  */
6782
6783 static void
6784 pa_label (int unused ATTRIBUTE_UNUSED)
6785 {
6786   char *name, c;
6787
6788   c = get_symbol_name (&name);
6789
6790   if (strlen (name) > 0)
6791     {
6792       colon (name);
6793       (void) restore_line_pointer (c);
6794     }
6795   else
6796     {
6797       as_warn (_("Missing label name on .LABEL"));
6798     }
6799
6800   if (!is_end_of_statement ())
6801     {
6802       as_warn (_("extra .LABEL arguments ignored."));
6803       ignore_rest_of_line ();
6804     }
6805   demand_empty_rest_of_line ();
6806 }
6807
6808 /* Handle a .LEAVE pseudo-op.  This is not supported yet.  */
6809
6810 static void
6811 pa_leave (int unused ATTRIBUTE_UNUSED)
6812 {
6813 #ifdef OBJ_SOM
6814   /* We must have a valid space and subspace.  */
6815   pa_check_current_space_and_subspace ();
6816 #endif
6817
6818   as_bad (_("The .LEAVE pseudo-op is not supported"));
6819   demand_empty_rest_of_line ();
6820 }
6821
6822 /* Handle a .LEVEL pseudo-op.  */
6823
6824 static void
6825 pa_level (int unused ATTRIBUTE_UNUSED)
6826 {
6827   char *level;
6828
6829   level = input_line_pointer;
6830   if (strncmp (level, "1.0", 3) == 0)
6831     {
6832       input_line_pointer += 3;
6833       if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 10))
6834         as_warn (_("could not set architecture and machine"));
6835     }
6836   else if (strncmp (level, "1.1", 3) == 0)
6837     {
6838       input_line_pointer += 3;
6839       if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 11))
6840         as_warn (_("could not set architecture and machine"));
6841     }
6842   else if (strncmp (level, "2.0w", 4) == 0)
6843     {
6844       input_line_pointer += 4;
6845       if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 25))
6846         as_warn (_("could not set architecture and machine"));
6847     }
6848   else if (strncmp (level, "2.0", 3) == 0)
6849     {
6850       input_line_pointer += 3;
6851       if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 20))
6852         as_warn (_("could not set architecture and machine"));
6853     }
6854   else
6855     {
6856       as_bad (_("Unrecognized .LEVEL argument\n"));
6857       ignore_rest_of_line ();
6858     }
6859   demand_empty_rest_of_line ();
6860 }
6861
6862 /* Handle a .ORIGIN pseudo-op.  */
6863
6864 static void
6865 pa_origin (int unused ATTRIBUTE_UNUSED)
6866 {
6867 #ifdef OBJ_SOM
6868   /* We must have a valid space and subspace.  */
6869   pa_check_current_space_and_subspace ();
6870 #endif
6871
6872   s_org (0);
6873   pa_undefine_label ();
6874 }
6875
6876 /* Handle a .PARAM pseudo-op.  This is much like a .EXPORT, except it
6877    is for static functions.  FIXME.  Should share more code with .EXPORT.  */
6878
6879 static void
6880 pa_param (int unused ATTRIBUTE_UNUSED)
6881 {
6882   char *name, c;
6883   symbolS *symbol;
6884
6885   c = get_symbol_name (&name);
6886
6887   if ((symbol = symbol_find_or_make (name)) == NULL)
6888     {
6889       as_bad (_("Cannot define static symbol: %s\n"), name);
6890       (void) restore_line_pointer (c);
6891       input_line_pointer++;
6892     }
6893   else
6894     {
6895       S_CLEAR_EXTERNAL (symbol);
6896       (void) restore_line_pointer (c);
6897       if (!is_end_of_statement ())
6898         {
6899           input_line_pointer++;
6900           pa_type_args (symbol, 0);
6901         }
6902     }
6903
6904   demand_empty_rest_of_line ();
6905 }
6906
6907 /* Handle a .PROC pseudo-op.  It is used to mark the beginning
6908    of a procedure from a syntactical point of view.  */
6909
6910 static void
6911 pa_proc (int unused ATTRIBUTE_UNUSED)
6912 {
6913   struct call_info *call_info;
6914
6915 #ifdef OBJ_SOM
6916   /* We must have a valid space and subspace.  */
6917   pa_check_current_space_and_subspace ();
6918 #endif
6919
6920   if (within_procedure)
6921     as_fatal (_("Nested procedures"));
6922
6923   /* Reset global variables for new procedure.  */
6924   callinfo_found = FALSE;
6925   within_procedure = TRUE;
6926
6927   /* Create another call_info structure.  */
6928   call_info = xmalloc (sizeof (struct call_info));
6929
6930   if (!call_info)
6931     as_fatal (_("Cannot allocate unwind descriptor\n"));
6932
6933   memset (call_info, 0, sizeof (struct call_info));
6934
6935   call_info->ci_next = NULL;
6936
6937   if (call_info_root == NULL)
6938     {
6939       call_info_root = call_info;
6940       last_call_info = call_info;
6941     }
6942   else
6943     {
6944       last_call_info->ci_next = call_info;
6945       last_call_info = call_info;
6946     }
6947
6948   /* set up defaults on call_info structure */
6949
6950   call_info->ci_unwind.descriptor.cannot_unwind = 0;
6951   call_info->ci_unwind.descriptor.region_desc = 1;
6952   call_info->ci_unwind.descriptor.hpux_interrupt_marker = 0;
6953
6954   /* If we got a .PROC pseudo-op, we know that the function is defined
6955      locally.  Make sure it gets into the symbol table.  */
6956   {
6957     label_symbol_struct *label_symbol = pa_get_label ();
6958
6959     if (label_symbol)
6960       {
6961         if (label_symbol->lss_label)
6962           {
6963             last_call_info->start_symbol = label_symbol->lss_label;
6964             symbol_get_bfdsym (label_symbol->lss_label)->flags |= BSF_FUNCTION;
6965           }
6966         else
6967           as_bad (_("Missing function name for .PROC (corrupted label chain)"));
6968       }
6969     else
6970       last_call_info->start_symbol = NULL;
6971   }
6972
6973   demand_empty_rest_of_line ();
6974 }
6975
6976 /* Process the syntactical end of a procedure.  Make sure all the
6977    appropriate pseudo-ops were found within the procedure.  */
6978
6979 static void
6980 pa_procend (int unused ATTRIBUTE_UNUSED)
6981 {
6982 #ifdef OBJ_SOM
6983   /* We must have a valid space and subspace.  */
6984   pa_check_current_space_and_subspace ();
6985 #endif
6986
6987   /* If we are within a procedure definition, make sure we've
6988      defined a label for the procedure; handle case where the
6989      label was defined after the .PROC directive.
6990
6991      Note there's not need to diddle with the segment or fragment
6992      for the label symbol in this case.  We have already switched
6993      into the new $CODE$ subspace at this point.  */
6994   if (within_procedure && last_call_info->start_symbol == NULL)
6995     {
6996       label_symbol_struct *label_symbol = pa_get_label ();
6997
6998       if (label_symbol)
6999         {
7000           if (label_symbol->lss_label)
7001             {
7002               last_call_info->start_symbol = label_symbol->lss_label;
7003               symbol_get_bfdsym (label_symbol->lss_label)->flags
7004                 |= BSF_FUNCTION;
7005 #ifdef OBJ_SOM
7006               /* Also handle allocation of a fixup to hold the unwind
7007                  information when the label appears after the proc/procend.  */
7008               if (within_entry_exit)
7009                 {
7010                   char *where;
7011                   unsigned int u;
7012
7013                   where = frag_more (0);
7014                   u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
7015                   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
7016                                 NULL, (offsetT) 0, NULL,
7017                                 0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
7018                 }
7019 #endif
7020             }
7021           else
7022             as_bad (_("Missing function name for .PROC (corrupted label chain)"));
7023         }
7024       else
7025         as_bad (_("Missing function name for .PROC"));
7026     }
7027
7028   if (!within_procedure)
7029     as_bad (_("misplaced .procend"));
7030
7031   if (!callinfo_found)
7032     as_bad (_("Missing .callinfo for this procedure"));
7033
7034   if (within_entry_exit)
7035     as_bad (_("Missing .EXIT for a .ENTRY"));
7036
7037 #ifdef OBJ_ELF
7038   /* ELF needs to mark the end of each function so that it can compute
7039      the size of the function (apparently its needed in the symbol table).  */
7040   hppa_elf_mark_end_of_function ();
7041 #endif
7042
7043   within_procedure = FALSE;
7044   demand_empty_rest_of_line ();
7045   pa_undefine_label ();
7046 }
7047
7048 #ifdef OBJ_SOM
7049 /* If VALUE is an exact power of two between zero and 2^31, then
7050    return log2 (VALUE).  Else return -1.  */
7051
7052 static int
7053 exact_log2 (int value)
7054 {
7055   int shift = 0;
7056
7057   while ((1 << shift) != value && shift < 32)
7058     shift++;
7059
7060   if (shift >= 32)
7061     return -1;
7062   else
7063     return shift;
7064 }
7065
7066 /* Check to make sure we have a valid space and subspace.  */
7067
7068 static void
7069 pa_check_current_space_and_subspace (void)
7070 {
7071   if (current_space == NULL)
7072     as_fatal (_("Not in a space.\n"));
7073
7074   if (current_subspace == NULL)
7075     as_fatal (_("Not in a subspace.\n"));
7076 }
7077
7078 /* Parse the parameters to a .SPACE directive; if CREATE_FLAG is nonzero,
7079    then create a new space entry to hold the information specified
7080    by the parameters to the .SPACE directive.  */
7081
7082 static sd_chain_struct *
7083 pa_parse_space_stmt (char *space_name, int create_flag)
7084 {
7085   char *name, *ptemp, c;
7086   char loadable, defined, private, sort;
7087   int spnum;
7088   asection *seg = NULL;
7089   sd_chain_struct *space;
7090
7091   /* Load default values.  */
7092   spnum = 0;
7093   sort = 0;
7094   loadable = TRUE;
7095   defined = TRUE;
7096   private = FALSE;
7097   if (strcmp (space_name, "$TEXT$") == 0)
7098     {
7099       seg = pa_def_spaces[0].segment;
7100       defined = pa_def_spaces[0].defined;
7101       private = pa_def_spaces[0].private;
7102       sort = pa_def_spaces[0].sort;
7103       spnum = pa_def_spaces[0].spnum;
7104     }
7105   else if (strcmp (space_name, "$PRIVATE$") == 0)
7106     {
7107       seg = pa_def_spaces[1].segment;
7108       defined = pa_def_spaces[1].defined;
7109       private = pa_def_spaces[1].private;
7110       sort = pa_def_spaces[1].sort;
7111       spnum = pa_def_spaces[1].spnum;
7112     }
7113
7114   if (!is_end_of_statement ())
7115     {
7116       print_errors = FALSE;
7117       ptemp = input_line_pointer + 1;
7118       /* First see if the space was specified as a number rather than
7119          as a name.  According to the PA assembly manual the rest of
7120          the line should be ignored.  */
7121       strict = 0;
7122       pa_parse_number (&ptemp, 0);
7123       if (pa_number >= 0)
7124         {
7125           spnum = pa_number;
7126           input_line_pointer = ptemp;
7127         }
7128       else
7129         {
7130           while (!is_end_of_statement ())
7131             {
7132               input_line_pointer++;
7133               c = get_symbol_name (&name);
7134               if ((strncasecmp (name, "spnum", 5) == 0))
7135                 {
7136                   (void) restore_line_pointer (c);
7137                   input_line_pointer++;
7138                   spnum = get_absolute_expression ();
7139                 }
7140               else if ((strncasecmp (name, "sort", 4) == 0))
7141                 {
7142                   (void) restore_line_pointer (c);
7143                   input_line_pointer++;
7144                   sort = get_absolute_expression ();
7145                 }
7146               else if ((strncasecmp (name, "unloadable", 10) == 0))
7147                 {
7148                   (void) restore_line_pointer (c);
7149                   loadable = FALSE;
7150                 }
7151               else if ((strncasecmp (name, "notdefined", 10) == 0))
7152                 {
7153                   (void) restore_line_pointer (c);
7154                   defined = FALSE;
7155                 }
7156               else if ((strncasecmp (name, "private", 7) == 0))
7157                 {
7158                   (void) restore_line_pointer (c);
7159                   private = TRUE;
7160                 }
7161               else
7162                 {
7163                   as_bad (_("Invalid .SPACE argument"));
7164                   (void) restore_line_pointer (c);
7165                   if (!is_end_of_statement ())
7166                     input_line_pointer++;
7167                 }
7168             }
7169         }
7170       print_errors = TRUE;
7171     }
7172
7173   if (create_flag && seg == NULL)
7174     seg = subseg_new (space_name, 0);
7175
7176   /* If create_flag is nonzero, then create the new space with
7177      the attributes computed above.  Else set the values in
7178      an already existing space -- this can only happen for
7179      the first occurrence of a built-in space.  */
7180   if (create_flag)
7181     space = create_new_space (space_name, spnum, loadable, defined,
7182                               private, sort, seg, 1);
7183   else
7184     {
7185       space = is_defined_space (space_name);
7186       SPACE_SPNUM (space) = spnum;
7187       SPACE_DEFINED (space) = defined & 1;
7188       SPACE_USER_DEFINED (space) = 1;
7189     }
7190
7191 #ifdef obj_set_section_attributes
7192   obj_set_section_attributes (seg, defined, private, sort, spnum);
7193 #endif
7194
7195   return space;
7196 }
7197
7198 /* Handle a .SPACE pseudo-op; this switches the current space to the
7199    given space, creating the new space if necessary.  */
7200
7201 static void
7202 pa_space (int unused ATTRIBUTE_UNUSED)
7203 {
7204   char *name, c, *space_name, *save_s;
7205   sd_chain_struct *sd_chain;
7206
7207   if (within_procedure)
7208     {
7209       as_bad (_("Can\'t change spaces within a procedure definition. Ignored"));
7210       ignore_rest_of_line ();
7211     }
7212   else
7213     {
7214       /* Check for some of the predefined spaces.   FIXME: most of the code
7215          below is repeated several times, can we extract the common parts
7216          and place them into a subroutine or something similar?  */
7217       /* FIXME Is this (and the next IF stmt) really right?
7218          What if INPUT_LINE_POINTER points to "$TEXT$FOO"?  */
7219       if (strncmp (input_line_pointer, "$TEXT$", 6) == 0)
7220         {
7221           input_line_pointer += 6;
7222           sd_chain = is_defined_space ("$TEXT$");
7223           if (sd_chain == NULL)
7224             sd_chain = pa_parse_space_stmt ("$TEXT$", 1);
7225           else if (SPACE_USER_DEFINED (sd_chain) == 0)
7226             sd_chain = pa_parse_space_stmt ("$TEXT$", 0);
7227
7228           current_space = sd_chain;
7229           subseg_set (text_section, sd_chain->sd_last_subseg);
7230           current_subspace
7231             = pa_subsegment_to_subspace (text_section,
7232                                          sd_chain->sd_last_subseg);
7233           demand_empty_rest_of_line ();
7234           return;
7235         }
7236       if (strncmp (input_line_pointer, "$PRIVATE$", 9) == 0)
7237         {
7238           input_line_pointer += 9;
7239           sd_chain = is_defined_space ("$PRIVATE$");
7240           if (sd_chain == NULL)
7241             sd_chain = pa_parse_space_stmt ("$PRIVATE$", 1);
7242           else if (SPACE_USER_DEFINED (sd_chain) == 0)
7243             sd_chain = pa_parse_space_stmt ("$PRIVATE$", 0);
7244
7245           current_space = sd_chain;
7246           subseg_set (data_section, sd_chain->sd_last_subseg);
7247           current_subspace
7248             = pa_subsegment_to_subspace (data_section,
7249                                          sd_chain->sd_last_subseg);
7250           demand_empty_rest_of_line ();
7251           return;
7252         }
7253       if (!strncasecmp (input_line_pointer,
7254                         GDB_DEBUG_SPACE_NAME,
7255                         strlen (GDB_DEBUG_SPACE_NAME)))
7256         {
7257           input_line_pointer += strlen (GDB_DEBUG_SPACE_NAME);
7258           sd_chain = is_defined_space (GDB_DEBUG_SPACE_NAME);
7259           if (sd_chain == NULL)
7260             sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 1);
7261           else if (SPACE_USER_DEFINED (sd_chain) == 0)
7262             sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 0);
7263
7264           current_space = sd_chain;
7265
7266           {
7267             asection *gdb_section
7268             = bfd_make_section_old_way (stdoutput, GDB_DEBUG_SPACE_NAME);
7269
7270             subseg_set (gdb_section, sd_chain->sd_last_subseg);
7271             current_subspace
7272               = pa_subsegment_to_subspace (gdb_section,
7273                                            sd_chain->sd_last_subseg);
7274           }
7275           demand_empty_rest_of_line ();
7276           return;
7277         }
7278
7279       /* It could be a space specified by number.  */
7280       print_errors = 0;
7281       save_s = input_line_pointer;
7282       strict = 0;
7283       pa_parse_number (&input_line_pointer, 0);
7284       if (pa_number >= 0)
7285         {
7286           if ((sd_chain = pa_find_space_by_number (pa_number)))
7287             {
7288               current_space = sd_chain;
7289
7290               subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
7291               current_subspace
7292                 = pa_subsegment_to_subspace (sd_chain->sd_seg,
7293                                              sd_chain->sd_last_subseg);
7294               demand_empty_rest_of_line ();
7295               return;
7296             }
7297         }
7298
7299       /* Not a number, attempt to create a new space.  */
7300       print_errors = 1;
7301       input_line_pointer = save_s;
7302       c = get_symbol_name (&name);
7303       space_name = xmalloc (strlen (name) + 1);
7304       strcpy (space_name, name);
7305       (void) restore_line_pointer (c);
7306
7307       sd_chain = pa_parse_space_stmt (space_name, 1);
7308       current_space = sd_chain;
7309
7310       subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
7311       current_subspace = pa_subsegment_to_subspace (sd_chain->sd_seg,
7312                                                   sd_chain->sd_last_subseg);
7313       demand_empty_rest_of_line ();
7314     }
7315 }
7316
7317 /* Switch to a new space.  (I think).  FIXME.  */
7318
7319 static void
7320 pa_spnum (int unused ATTRIBUTE_UNUSED)
7321 {
7322   char *name;
7323   char c;
7324   char *p;
7325   sd_chain_struct *space;
7326
7327   c = get_symbol_name (&name);
7328   space = is_defined_space (name);
7329   if (space)
7330     {
7331       p = frag_more (4);
7332       md_number_to_chars (p, SPACE_SPNUM (space), 4);
7333     }
7334   else
7335     as_warn (_("Undefined space: '%s' Assuming space number = 0."), name);
7336
7337   (void) restore_line_pointer (c);
7338   demand_empty_rest_of_line ();
7339 }
7340
7341 /* Handle a .SUBSPACE pseudo-op; this switches the current subspace to the
7342    given subspace, creating the new subspace if necessary.
7343
7344    FIXME.  Should mirror pa_space more closely, in particular how
7345    they're broken up into subroutines.  */
7346
7347 static void
7348 pa_subspace (int create_new)
7349 {
7350   char *name, *ss_name, c;
7351   char loadable, code_only, comdat, common, dup_common, zero, sort;
7352   int i, access_ctr, space_index, alignment, quadrant, applicable, flags;
7353   sd_chain_struct *space;
7354   ssd_chain_struct *ssd;
7355   asection *section;
7356
7357   if (current_space == NULL)
7358     as_fatal (_("Must be in a space before changing or declaring subspaces.\n"));
7359
7360   if (within_procedure)
7361     {
7362       as_bad (_("Can\'t change subspaces within a procedure definition. Ignored"));
7363       ignore_rest_of_line ();
7364     }
7365   else
7366     {
7367       c = get_symbol_name (&name);
7368       ss_name = xmalloc (strlen (name) + 1);
7369       strcpy (ss_name, name);
7370       (void) restore_line_pointer (c);
7371
7372       /* Load default values.  */
7373       sort = 0;
7374       access_ctr = 0x7f;
7375       loadable = 1;
7376       comdat = 0;
7377       common = 0;
7378       dup_common = 0;
7379       code_only = 0;
7380       zero = 0;
7381       space_index = ~0;
7382       alignment = 1;
7383       quadrant = 0;
7384
7385       space = current_space;
7386       if (create_new)
7387         ssd = NULL;
7388       else
7389         ssd = is_defined_subspace (ss_name);
7390       /* Allow user to override the builtin attributes of subspaces.  But
7391          only allow the attributes to be changed once!  */
7392       if (ssd && SUBSPACE_DEFINED (ssd))
7393         {
7394           subseg_set (ssd->ssd_seg, ssd->ssd_subseg);
7395           current_subspace = ssd;
7396           if (!is_end_of_statement ())
7397             as_warn (_("Parameters of an existing subspace can\'t be modified"));
7398           demand_empty_rest_of_line ();
7399           return;
7400         }
7401       else
7402         {
7403           /* A new subspace.  Load default values if it matches one of
7404              the builtin subspaces.  */
7405           i = 0;
7406           while (pa_def_subspaces[i].name)
7407             {
7408               if (strcasecmp (pa_def_subspaces[i].name, ss_name) == 0)
7409                 {
7410                   loadable = pa_def_subspaces[i].loadable;
7411                   comdat = pa_def_subspaces[i].comdat;
7412                   common = pa_def_subspaces[i].common;
7413                   dup_common = pa_def_subspaces[i].dup_common;
7414                   code_only = pa_def_subspaces[i].code_only;
7415                   zero = pa_def_subspaces[i].zero;
7416                   space_index = pa_def_subspaces[i].space_index;
7417                   alignment = pa_def_subspaces[i].alignment;
7418                   quadrant = pa_def_subspaces[i].quadrant;
7419                   access_ctr = pa_def_subspaces[i].access;
7420                   sort = pa_def_subspaces[i].sort;
7421                   break;
7422                 }
7423               i++;
7424             }
7425         }
7426
7427       /* We should be working with a new subspace now.  Fill in
7428          any information as specified by the user.  */
7429       if (!is_end_of_statement ())
7430         {
7431           input_line_pointer++;
7432           while (!is_end_of_statement ())
7433             {
7434               c = get_symbol_name (&name);
7435               if ((strncasecmp (name, "quad", 4) == 0))
7436                 {
7437                   (void) restore_line_pointer (c);
7438                   input_line_pointer++;
7439                   quadrant = get_absolute_expression ();
7440                 }
7441               else if ((strncasecmp (name, "align", 5) == 0))
7442                 {
7443                   (void) restore_line_pointer (c);
7444                   input_line_pointer++;
7445                   alignment = get_absolute_expression ();
7446                   if (exact_log2 (alignment) == -1)
7447                     {
7448                       as_bad (_("Alignment must be a power of 2"));
7449                       alignment = 1;
7450                     }
7451                 }
7452               else if ((strncasecmp (name, "access", 6) == 0))
7453                 {
7454                   (void) restore_line_pointer (c);
7455                   input_line_pointer++;
7456                   access_ctr = get_absolute_expression ();
7457                 }
7458               else if ((strncasecmp (name, "sort", 4) == 0))
7459                 {
7460                   (void) restore_line_pointer (c);
7461                   input_line_pointer++;
7462                   sort = get_absolute_expression ();
7463                 }
7464               else if ((strncasecmp (name, "code_only", 9) == 0))
7465                 {
7466                   (void) restore_line_pointer (c);
7467                   code_only = 1;
7468                 }
7469               else if ((strncasecmp (name, "unloadable", 10) == 0))
7470                 {
7471                   (void) restore_line_pointer (c);
7472                   loadable = 0;
7473                 }
7474               else if ((strncasecmp (name, "comdat", 6) == 0))
7475                 {
7476                   (void) restore_line_pointer (c);
7477                   comdat = 1;
7478                 }
7479               else if ((strncasecmp (name, "common", 6) == 0))
7480                 {
7481                   (void) restore_line_pointer (c);
7482                   common = 1;
7483                 }
7484               else if ((strncasecmp (name, "dup_comm", 8) == 0))
7485                 {
7486                   (void) restore_line_pointer (c);
7487                   dup_common = 1;
7488                 }
7489               else if ((strncasecmp (name, "zero", 4) == 0))
7490                 {
7491                   (void) restore_line_pointer (c);
7492                   zero = 1;
7493                 }
7494               else if ((strncasecmp (name, "first", 5) == 0))
7495                 as_bad (_("FIRST not supported as a .SUBSPACE argument"));
7496               else
7497                 as_bad (_("Invalid .SUBSPACE argument"));
7498
7499               if (!is_end_of_statement ())
7500                 input_line_pointer++;
7501             }
7502         }
7503
7504       /* Compute a reasonable set of BFD flags based on the information
7505          in the .subspace directive.  */
7506       applicable = bfd_applicable_section_flags (stdoutput);
7507       flags = 0;
7508       if (loadable)
7509         flags |= (SEC_ALLOC | SEC_LOAD);
7510       if (code_only)
7511         flags |= SEC_CODE;
7512
7513       /* These flags are used to implement various flavors of initialized
7514          common.  The SOM linker discards duplicate subspaces when they
7515          have the same "key" symbol name.  This support is more like
7516          GNU linkonce than BFD common.  Further, pc-relative relocations
7517          are converted to section relative relocations in BFD common
7518          sections.  This complicates the handling of relocations in
7519          common sections containing text and isn't currently supported
7520          correctly in the SOM BFD backend.  */
7521       if (comdat || common || dup_common)
7522         flags |= SEC_LINK_ONCE;
7523
7524       flags |= SEC_RELOC | SEC_HAS_CONTENTS;
7525
7526       /* This is a zero-filled subspace (eg BSS).  */
7527       if (zero)
7528         flags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
7529
7530       applicable &= flags;
7531
7532       /* If this is an existing subspace, then we want to use the
7533          segment already associated with the subspace.
7534
7535          FIXME NOW!  ELF BFD doesn't appear to be ready to deal with
7536          lots of sections.  It might be a problem in the PA ELF
7537          code, I do not know yet.  For now avoid creating anything
7538          but the "standard" sections for ELF.  */
7539       if (create_new)
7540         section = subseg_force_new (ss_name, 0);
7541       else if (ssd)
7542         section = ssd->ssd_seg;
7543       else
7544         section = subseg_new (ss_name, 0);
7545
7546       if (zero)
7547         seg_info (section)->bss = 1;
7548
7549       /* Now set the flags.  */
7550       bfd_set_section_flags (stdoutput, section, applicable);
7551
7552       /* Record any alignment request for this section.  */
7553       record_alignment (section, exact_log2 (alignment));
7554
7555       /* Set the starting offset for this section.  */
7556       bfd_set_section_vma (stdoutput, section,
7557                            pa_subspace_start (space, quadrant));
7558
7559       /* Now that all the flags are set, update an existing subspace,
7560          or create a new one.  */
7561       if (ssd)
7562
7563         current_subspace = update_subspace (space, ss_name, loadable,
7564                                             code_only, comdat, common,
7565                                             dup_common, sort, zero, access_ctr,
7566                                             space_index, alignment, quadrant,
7567                                             section);
7568       else
7569         current_subspace = create_new_subspace (space, ss_name, loadable,
7570                                                 code_only, comdat, common,
7571                                                 dup_common, zero, sort,
7572                                                 access_ctr, space_index,
7573                                                 alignment, quadrant, section);
7574
7575       demand_empty_rest_of_line ();
7576       current_subspace->ssd_seg = section;
7577       subseg_set (current_subspace->ssd_seg, current_subspace->ssd_subseg);
7578     }
7579   SUBSPACE_DEFINED (current_subspace) = 1;
7580 }
7581
7582 /* Create default space and subspace dictionaries.  */
7583
7584 static void
7585 pa_spaces_begin (void)
7586 {
7587   int i;
7588
7589   space_dict_root = NULL;
7590   space_dict_last = NULL;
7591
7592   i = 0;
7593   while (pa_def_spaces[i].name)
7594     {
7595       char *name;
7596
7597       /* Pick the right name to use for the new section.  */
7598       name = pa_def_spaces[i].name;
7599
7600       pa_def_spaces[i].segment = subseg_new (name, 0);
7601       create_new_space (pa_def_spaces[i].name, pa_def_spaces[i].spnum,
7602                         pa_def_spaces[i].loadable, pa_def_spaces[i].defined,
7603                         pa_def_spaces[i].private, pa_def_spaces[i].sort,
7604                         pa_def_spaces[i].segment, 0);
7605       i++;
7606     }
7607
7608   i = 0;
7609   while (pa_def_subspaces[i].name)
7610     {
7611       char *name;
7612       int applicable, subsegment;
7613       asection *segment = NULL;
7614       sd_chain_struct *space;
7615
7616       /* Pick the right name for the new section and pick the right
7617          subsegment number.  */
7618       name = pa_def_subspaces[i].name;
7619       subsegment = 0;
7620
7621       /* Create the new section.  */
7622       segment = subseg_new (name, subsegment);
7623
7624       /* For SOM we want to replace the standard .text, .data, and .bss
7625          sections with our own.   We also want to set BFD flags for
7626          all the built-in subspaces.  */
7627       if (!strcmp (pa_def_subspaces[i].name, "$CODE$"))
7628         {
7629           text_section = segment;
7630           applicable = bfd_applicable_section_flags (stdoutput);
7631           bfd_set_section_flags (stdoutput, segment,
7632                                  applicable & (SEC_ALLOC | SEC_LOAD
7633                                                | SEC_RELOC | SEC_CODE
7634                                                | SEC_READONLY
7635                                                | SEC_HAS_CONTENTS));
7636         }
7637       else if (!strcmp (pa_def_subspaces[i].name, "$DATA$"))
7638         {
7639           data_section = segment;
7640           applicable = bfd_applicable_section_flags (stdoutput);
7641           bfd_set_section_flags (stdoutput, segment,
7642                                  applicable & (SEC_ALLOC | SEC_LOAD
7643                                                | SEC_RELOC
7644                                                | SEC_HAS_CONTENTS));
7645
7646         }
7647       else if (!strcmp (pa_def_subspaces[i].name, "$BSS$"))
7648         {
7649           bss_section = segment;
7650           applicable = bfd_applicable_section_flags (stdoutput);
7651           bfd_set_section_flags (stdoutput, segment,
7652                                  applicable & SEC_ALLOC);
7653         }
7654       else if (!strcmp (pa_def_subspaces[i].name, "$LIT$"))
7655         {
7656           applicable = bfd_applicable_section_flags (stdoutput);
7657           bfd_set_section_flags (stdoutput, segment,
7658                                  applicable & (SEC_ALLOC | SEC_LOAD
7659                                                | SEC_RELOC
7660                                                | SEC_READONLY
7661                                                | SEC_HAS_CONTENTS));
7662         }
7663       else if (!strcmp (pa_def_subspaces[i].name, "$MILLICODE$"))
7664         {
7665           applicable = bfd_applicable_section_flags (stdoutput);
7666           bfd_set_section_flags (stdoutput, segment,
7667                                  applicable & (SEC_ALLOC | SEC_LOAD
7668                                                | SEC_RELOC
7669                                                | SEC_READONLY
7670                                                | SEC_HAS_CONTENTS));
7671         }
7672       else if (!strcmp (pa_def_subspaces[i].name, "$UNWIND$"))
7673         {
7674           applicable = bfd_applicable_section_flags (stdoutput);
7675           bfd_set_section_flags (stdoutput, segment,
7676                                  applicable & (SEC_ALLOC | SEC_LOAD
7677                                                | SEC_RELOC
7678                                                | SEC_READONLY
7679                                                | SEC_HAS_CONTENTS));
7680         }
7681
7682       /* Find the space associated with this subspace.  */
7683       space = pa_segment_to_space (pa_def_spaces[pa_def_subspaces[i].
7684                                                  def_space_index].segment);
7685       if (space == NULL)
7686         {
7687           as_fatal (_("Internal error: Unable to find containing space for %s."),
7688                     pa_def_subspaces[i].name);
7689         }
7690
7691       create_new_subspace (space, name,
7692                            pa_def_subspaces[i].loadable,
7693                            pa_def_subspaces[i].code_only,
7694                            pa_def_subspaces[i].comdat,
7695                            pa_def_subspaces[i].common,
7696                            pa_def_subspaces[i].dup_common,
7697                            pa_def_subspaces[i].zero,
7698                            pa_def_subspaces[i].sort,
7699                            pa_def_subspaces[i].access,
7700                            pa_def_subspaces[i].space_index,
7701                            pa_def_subspaces[i].alignment,
7702                            pa_def_subspaces[i].quadrant,
7703                            segment);
7704       i++;
7705     }
7706 }
7707
7708 /* Create a new space NAME, with the appropriate flags as defined
7709    by the given parameters.  */
7710
7711 static sd_chain_struct *
7712 create_new_space (char *name,
7713                   int spnum,
7714                   int loadable ATTRIBUTE_UNUSED,
7715                   int defined,
7716                   int private,
7717                   int sort,
7718                   asection *seg,
7719                   int user_defined)
7720 {
7721   sd_chain_struct *chain_entry;
7722
7723   chain_entry = xmalloc (sizeof (sd_chain_struct));
7724   if (!chain_entry)
7725     as_fatal (_("Out of memory: could not allocate new space chain entry: %s\n"),
7726               name);
7727
7728   SPACE_NAME (chain_entry) = xmalloc (strlen (name) + 1);
7729   strcpy (SPACE_NAME (chain_entry), name);
7730   SPACE_DEFINED (chain_entry) = defined;
7731   SPACE_USER_DEFINED (chain_entry) = user_defined;
7732   SPACE_SPNUM (chain_entry) = spnum;
7733
7734   chain_entry->sd_seg = seg;
7735   chain_entry->sd_last_subseg = -1;
7736   chain_entry->sd_subspaces = NULL;
7737   chain_entry->sd_next = NULL;
7738
7739   /* Find spot for the new space based on its sort key.  */
7740   if (!space_dict_last)
7741     space_dict_last = chain_entry;
7742
7743   if (space_dict_root == NULL)
7744     space_dict_root = chain_entry;
7745   else
7746     {
7747       sd_chain_struct *chain_pointer;
7748       sd_chain_struct *prev_chain_pointer;
7749
7750       chain_pointer = space_dict_root;
7751       prev_chain_pointer = NULL;
7752
7753       while (chain_pointer)
7754         {
7755           prev_chain_pointer = chain_pointer;
7756           chain_pointer = chain_pointer->sd_next;
7757         }
7758
7759       /* At this point we've found the correct place to add the new
7760          entry.  So add it and update the linked lists as appropriate.  */
7761       if (prev_chain_pointer)
7762         {
7763           chain_entry->sd_next = chain_pointer;
7764           prev_chain_pointer->sd_next = chain_entry;
7765         }
7766       else
7767         {
7768           space_dict_root = chain_entry;
7769           chain_entry->sd_next = chain_pointer;
7770         }
7771
7772       if (chain_entry->sd_next == NULL)
7773         space_dict_last = chain_entry;
7774     }
7775
7776   /* This is here to catch predefined spaces which do not get
7777      modified by the user's input.  Another call is found at
7778      the bottom of pa_parse_space_stmt to handle cases where
7779      the user modifies a predefined space.  */
7780 #ifdef obj_set_section_attributes
7781   obj_set_section_attributes (seg, defined, private, sort, spnum);
7782 #endif
7783
7784   return chain_entry;
7785 }
7786
7787 /* Create a new subspace NAME, with the appropriate flags as defined
7788    by the given parameters.
7789
7790    Add the new subspace to the subspace dictionary chain in numerical
7791    order as defined by the SORT entries.  */
7792
7793 static ssd_chain_struct *
7794 create_new_subspace (sd_chain_struct *space,
7795                      char *name,
7796                      int loadable ATTRIBUTE_UNUSED,
7797                      int code_only ATTRIBUTE_UNUSED,
7798                      int comdat,
7799                      int common,
7800                      int dup_common,
7801                      int is_zero ATTRIBUTE_UNUSED,
7802                      int sort,
7803                      int access_ctr,
7804                      int space_index ATTRIBUTE_UNUSED,
7805                      int alignment ATTRIBUTE_UNUSED,
7806                      int quadrant,
7807                      asection *seg)
7808 {
7809   ssd_chain_struct *chain_entry;
7810
7811   chain_entry = xmalloc (sizeof (ssd_chain_struct));
7812   if (!chain_entry)
7813     as_fatal (_("Out of memory: could not allocate new subspace chain entry: %s\n"), name);
7814
7815   SUBSPACE_NAME (chain_entry) = xmalloc (strlen (name) + 1);
7816   strcpy (SUBSPACE_NAME (chain_entry), name);
7817
7818   /* Initialize subspace_defined.  When we hit a .subspace directive
7819      we'll set it to 1 which "locks-in" the subspace attributes.  */
7820   SUBSPACE_DEFINED (chain_entry) = 0;
7821
7822   chain_entry->ssd_subseg = 0;
7823   chain_entry->ssd_seg = seg;
7824   chain_entry->ssd_next = NULL;
7825
7826   /* Find spot for the new subspace based on its sort key.  */
7827   if (space->sd_subspaces == NULL)
7828     space->sd_subspaces = chain_entry;
7829   else
7830     {
7831       ssd_chain_struct *chain_pointer;
7832       ssd_chain_struct *prev_chain_pointer;
7833
7834       chain_pointer = space->sd_subspaces;
7835       prev_chain_pointer = NULL;
7836
7837       while (chain_pointer)
7838         {
7839           prev_chain_pointer = chain_pointer;
7840           chain_pointer = chain_pointer->ssd_next;
7841         }
7842
7843       /* Now we have somewhere to put the new entry.  Insert it and update
7844          the links.  */
7845       if (prev_chain_pointer)
7846         {
7847           chain_entry->ssd_next = chain_pointer;
7848           prev_chain_pointer->ssd_next = chain_entry;
7849         }
7850       else
7851         {
7852           space->sd_subspaces = chain_entry;
7853           chain_entry->ssd_next = chain_pointer;
7854         }
7855     }
7856
7857 #ifdef obj_set_subsection_attributes
7858   obj_set_subsection_attributes (seg, space->sd_seg, access_ctr, sort,
7859                                  quadrant, comdat, common, dup_common);
7860 #endif
7861
7862   return chain_entry;
7863 }
7864
7865 /* Update the information for the given subspace based upon the
7866    various arguments.   Return the modified subspace chain entry.  */
7867
7868 static ssd_chain_struct *
7869 update_subspace (sd_chain_struct *space,
7870                  char *name,
7871                  int loadable ATTRIBUTE_UNUSED,
7872                  int code_only ATTRIBUTE_UNUSED,
7873                  int comdat,
7874                  int common,
7875                  int dup_common,
7876                  int sort,
7877                  int zero ATTRIBUTE_UNUSED,
7878                  int access_ctr,
7879                  int space_index ATTRIBUTE_UNUSED,
7880                  int alignment ATTRIBUTE_UNUSED,
7881                  int quadrant,
7882                  asection *section)
7883 {
7884   ssd_chain_struct *chain_entry;
7885
7886   chain_entry = is_defined_subspace (name);
7887
7888 #ifdef obj_set_subsection_attributes
7889   obj_set_subsection_attributes (section, space->sd_seg, access_ctr, sort,
7890                                  quadrant, comdat, common, dup_common);
7891 #endif
7892
7893   return chain_entry;
7894 }
7895
7896 /* Return the space chain entry for the space with the name NAME or
7897    NULL if no such space exists.  */
7898
7899 static sd_chain_struct *
7900 is_defined_space (char *name)
7901 {
7902   sd_chain_struct *chain_pointer;
7903
7904   for (chain_pointer = space_dict_root;
7905        chain_pointer;
7906        chain_pointer = chain_pointer->sd_next)
7907     if (strcmp (SPACE_NAME (chain_pointer), name) == 0)
7908       return chain_pointer;
7909
7910   /* No mapping from segment to space was found.  Return NULL.  */
7911   return NULL;
7912 }
7913
7914 /* Find and return the space associated with the given seg.  If no mapping
7915    from the given seg to a space is found, then return NULL.
7916
7917    Unlike subspaces, the number of spaces is not expected to grow much,
7918    so a linear exhaustive search is OK here.  */
7919
7920 static sd_chain_struct *
7921 pa_segment_to_space (asection *seg)
7922 {
7923   sd_chain_struct *space_chain;
7924
7925   /* Walk through each space looking for the correct mapping.  */
7926   for (space_chain = space_dict_root;
7927        space_chain;
7928        space_chain = space_chain->sd_next)
7929     if (space_chain->sd_seg == seg)
7930       return space_chain;
7931
7932   /* Mapping was not found.  Return NULL.  */
7933   return NULL;
7934 }
7935
7936 /* Return the first space chain entry for the subspace with the name
7937    NAME or NULL if no such subspace exists.
7938
7939    When there are multiple subspaces with the same name, switching to
7940    the first (i.e., default) subspace is preferable in most situations.
7941    For example, it wouldn't be desirable to merge COMDAT data with non
7942    COMDAT data.
7943
7944    Uses a linear search through all the spaces and subspaces, this may
7945    not be appropriate if we ever being placing each function in its
7946    own subspace.  */
7947
7948 static ssd_chain_struct *
7949 is_defined_subspace (char *name)
7950 {
7951   sd_chain_struct *space_chain;
7952   ssd_chain_struct *subspace_chain;
7953
7954   /* Walk through each space.  */
7955   for (space_chain = space_dict_root;
7956        space_chain;
7957        space_chain = space_chain->sd_next)
7958     {
7959       /* Walk through each subspace looking for a name which matches.  */
7960       for (subspace_chain = space_chain->sd_subspaces;
7961            subspace_chain;
7962            subspace_chain = subspace_chain->ssd_next)
7963         if (strcmp (SUBSPACE_NAME (subspace_chain), name) == 0)
7964           return subspace_chain;
7965     }
7966
7967   /* Subspace wasn't found.  Return NULL.  */
7968   return NULL;
7969 }
7970
7971 /* Find and return the subspace associated with the given seg.  If no
7972    mapping from the given seg to a subspace is found, then return NULL.
7973
7974    If we ever put each procedure/function within its own subspace
7975    (to make life easier on the compiler and linker), then this will have
7976    to become more efficient.  */
7977
7978 static ssd_chain_struct *
7979 pa_subsegment_to_subspace (asection *seg, subsegT subseg)
7980 {
7981   sd_chain_struct *space_chain;
7982   ssd_chain_struct *subspace_chain;
7983
7984   /* Walk through each space.  */
7985   for (space_chain = space_dict_root;
7986        space_chain;
7987        space_chain = space_chain->sd_next)
7988     {
7989       if (space_chain->sd_seg == seg)
7990         {
7991           /* Walk through each subspace within each space looking for
7992              the correct mapping.  */
7993           for (subspace_chain = space_chain->sd_subspaces;
7994                subspace_chain;
7995                subspace_chain = subspace_chain->ssd_next)
7996             if (subspace_chain->ssd_subseg == (int) subseg)
7997               return subspace_chain;
7998         }
7999     }
8000
8001   /* No mapping from subsegment to subspace found.  Return NULL.  */
8002   return NULL;
8003 }
8004
8005 /* Given a number, try and find a space with the name number.
8006
8007    Return a pointer to a space dictionary chain entry for the space
8008    that was found or NULL on failure.  */
8009
8010 static sd_chain_struct *
8011 pa_find_space_by_number (int number)
8012 {
8013   sd_chain_struct *space_chain;
8014
8015   for (space_chain = space_dict_root;
8016        space_chain;
8017        space_chain = space_chain->sd_next)
8018     {
8019       if (SPACE_SPNUM (space_chain) == (unsigned int) number)
8020         return space_chain;
8021     }
8022
8023   /* No appropriate space found.  Return NULL.  */
8024   return NULL;
8025 }
8026
8027 /* Return the starting address for the given subspace.  If the starting
8028    address is unknown then return zero.  */
8029
8030 static unsigned int
8031 pa_subspace_start (sd_chain_struct *space, int quadrant)
8032 {
8033   /* FIXME.  Assumes everyone puts read/write data at 0x4000000, this
8034      is not correct for the PA OSF1 port.  */
8035   if ((strcmp (SPACE_NAME (space), "$PRIVATE$") == 0) && quadrant == 1)
8036     return 0x40000000;
8037   else if (space->sd_seg == data_section && quadrant == 1)
8038     return 0x40000000;
8039   else
8040     return 0;
8041   return 0;
8042 }
8043 #endif
8044
8045 /* Helper function for pa_stringer.  Used to find the end of
8046    a string.  */
8047
8048 static unsigned int
8049 pa_stringer_aux (char *s)
8050 {
8051   unsigned int c = *s & CHAR_MASK;
8052
8053   switch (c)
8054     {
8055     case '\"':
8056       c = NOT_A_CHAR;
8057       break;
8058     default:
8059       break;
8060     }
8061   return c;
8062 }
8063
8064 /* Handle a .STRING type pseudo-op.  */
8065
8066 static void
8067 pa_stringer (int append_zero)
8068 {
8069   char *s, num_buf[4];
8070   unsigned int c;
8071   int i;
8072
8073   /* Preprocess the string to handle PA-specific escape sequences.
8074      For example, \xDD where DD is a hexadecimal number should be
8075      changed to \OOO where OOO is an octal number.  */
8076
8077 #ifdef OBJ_SOM
8078   /* We must have a valid space and subspace.  */
8079   pa_check_current_space_and_subspace ();
8080 #endif
8081
8082   /* Skip the opening quote.  */
8083   s = input_line_pointer + 1;
8084
8085   while (is_a_char (c = pa_stringer_aux (s++)))
8086     {
8087       if (c == '\\')
8088         {
8089           c = *s;
8090           switch (c)
8091             {
8092               /* Handle \x<num>.  */
8093             case 'x':
8094               {
8095                 unsigned int number;
8096                 int num_digit;
8097                 char dg;
8098                 char *s_start = s;
8099
8100                 /* Get past the 'x'.  */
8101                 s++;
8102                 for (num_digit = 0, number = 0, dg = *s;
8103                      num_digit < 2
8104                      && (ISDIGIT (dg) || (dg >= 'a' && dg <= 'f')
8105                          || (dg >= 'A' && dg <= 'F'));
8106                      num_digit++)
8107                   {
8108                     if (ISDIGIT (dg))
8109                       number = number * 16 + dg - '0';
8110                     else if (dg >= 'a' && dg <= 'f')
8111                       number = number * 16 + dg - 'a' + 10;
8112                     else
8113                       number = number * 16 + dg - 'A' + 10;
8114
8115                     s++;
8116                     dg = *s;
8117                   }
8118                 if (num_digit > 0)
8119                   {
8120                     switch (num_digit)
8121                       {
8122                       case 1:
8123                         sprintf (num_buf, "%02o", number);
8124                         break;
8125                       case 2:
8126                         sprintf (num_buf, "%03o", number);
8127                         break;
8128                       }
8129                     for (i = 0; i <= num_digit; i++)
8130                       s_start[i] = num_buf[i];
8131                   }
8132                 break;
8133               }
8134             /* This might be a "\"", skip over the escaped char.  */
8135             default:
8136               s++;
8137               break;
8138             }
8139         }
8140     }
8141   stringer (8 + append_zero);
8142   pa_undefine_label ();
8143 }
8144
8145 /* Handle a .VERSION pseudo-op.  */
8146
8147 static void
8148 pa_version (int unused ATTRIBUTE_UNUSED)
8149 {
8150   obj_version (0);
8151   pa_undefine_label ();
8152 }
8153
8154 #ifdef OBJ_SOM
8155
8156 /* Handle a .COMPILER pseudo-op.  */
8157
8158 static void
8159 pa_compiler (int unused ATTRIBUTE_UNUSED)
8160 {
8161   obj_som_compiler (0);
8162   pa_undefine_label ();
8163 }
8164
8165 #endif
8166
8167 /* Handle a .COPYRIGHT pseudo-op.  */
8168
8169 static void
8170 pa_copyright (int unused ATTRIBUTE_UNUSED)
8171 {
8172   obj_copyright (0);
8173   pa_undefine_label ();
8174 }
8175
8176 /* Just like a normal cons, but when finished we have to undefine
8177    the latest space label.  */
8178
8179 static void
8180 pa_cons (int nbytes)
8181 {
8182   cons (nbytes);
8183   pa_undefine_label ();
8184 }
8185
8186 /* Like float_cons, but we need to undefine our label.  */
8187
8188 static void
8189 pa_float_cons (int float_type)
8190 {
8191   float_cons (float_type);
8192   pa_undefine_label ();
8193 }
8194
8195 /* Like s_fill, but delete our label when finished.  */
8196
8197 static void
8198 pa_fill (int unused ATTRIBUTE_UNUSED)
8199 {
8200 #ifdef OBJ_SOM
8201   /* We must have a valid space and subspace.  */
8202   pa_check_current_space_and_subspace ();
8203 #endif
8204
8205   s_fill (0);
8206   pa_undefine_label ();
8207 }
8208
8209 /* Like lcomm, but delete our label when finished.  */
8210
8211 static void
8212 pa_lcomm (int needs_align)
8213 {
8214 #ifdef OBJ_SOM
8215   /* We must have a valid space and subspace.  */
8216   pa_check_current_space_and_subspace ();
8217 #endif
8218
8219   s_lcomm (needs_align);
8220   pa_undefine_label ();
8221 }
8222
8223 /* Like lsym, but delete our label when finished.  */
8224
8225 static void
8226 pa_lsym (int unused ATTRIBUTE_UNUSED)
8227 {
8228 #ifdef OBJ_SOM
8229   /* We must have a valid space and subspace.  */
8230   pa_check_current_space_and_subspace ();
8231 #endif
8232
8233   s_lsym (0);
8234   pa_undefine_label ();
8235 }
8236
8237 /* This function is called once, at assembler startup time.  It should
8238    set up all the tables, etc. that the MD part of the assembler will need.  */
8239
8240 void
8241 md_begin (void)
8242 {
8243   const char *retval = NULL;
8244   int lose = 0;
8245   unsigned int i = 0;
8246
8247   last_call_info = NULL;
8248   call_info_root = NULL;
8249
8250   /* Set the default machine type.  */
8251   if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, DEFAULT_LEVEL))
8252     as_warn (_("could not set architecture and machine"));
8253
8254   /* Folding of text and data segments fails miserably on the PA.
8255      Warn user and disable "-R" option.  */
8256   if (flag_readonly_data_in_text)
8257     {
8258       as_warn (_("-R option not supported on this target."));
8259       flag_readonly_data_in_text = 0;
8260     }
8261
8262 #ifdef OBJ_SOM
8263   pa_spaces_begin ();
8264 #endif
8265
8266   op_hash = hash_new ();
8267
8268   while (i < NUMOPCODES)
8269     {
8270       const char *name = pa_opcodes[i].name;
8271
8272       retval = hash_insert (op_hash, name, (struct pa_opcode *) &pa_opcodes[i]);
8273       if (retval != NULL && *retval != '\0')
8274         {
8275           as_fatal (_("Internal error: can't hash `%s': %s\n"), name, retval);
8276           lose = 1;
8277         }
8278
8279       do
8280         {
8281           if ((pa_opcodes[i].match & pa_opcodes[i].mask)
8282               != pa_opcodes[i].match)
8283             {
8284               fprintf (stderr, _("internal error: losing opcode: `%s' \"%s\"\n"),
8285                        pa_opcodes[i].name, pa_opcodes[i].args);
8286               lose = 1;
8287             }
8288           ++i;
8289         }
8290       while (i < NUMOPCODES && !strcmp (pa_opcodes[i].name, name));
8291     }
8292
8293   if (lose)
8294     as_fatal (_("Broken assembler.  No assembly attempted."));
8295
8296 #ifdef OBJ_SOM
8297   /* SOM will change text_section.  To make sure we never put
8298      anything into the old one switch to the new one now.  */
8299   subseg_set (text_section, 0);
8300 #endif
8301
8302 #ifdef OBJ_SOM
8303   dummy_symbol = symbol_find_or_make ("L$dummy");
8304   S_SET_SEGMENT (dummy_symbol, text_section);
8305   /* Force the symbol to be converted to a real symbol.  */
8306   symbol_get_bfdsym (dummy_symbol)->flags |= BSF_KEEP;
8307 #endif
8308 }
8309
8310 /* On the PA relocations which involve function symbols must not be
8311    adjusted.  This so that the linker can know when/how to create argument
8312    relocation stubs for indirect calls and calls to static functions.
8313
8314    "T" field selectors create DLT relative fixups for accessing
8315    globals and statics in PIC code; each DLT relative fixup creates
8316    an entry in the DLT table.  The entries contain the address of
8317    the final target (eg accessing "foo" would create a DLT entry
8318    with the address of "foo").
8319
8320    Unfortunately, the HP linker doesn't take into account any addend
8321    when generating the DLT; so accessing $LIT$+8 puts the address of
8322    $LIT$ into the DLT rather than the address of $LIT$+8.
8323
8324    The end result is we can't perform relocation symbol reductions for
8325    any fixup which creates entries in the DLT (eg they use "T" field
8326    selectors).
8327
8328    ??? Reject reductions involving symbols with external scope; such
8329    reductions make life a living hell for object file editors.  */
8330
8331 int
8332 hppa_fix_adjustable (fixS *fixp)
8333 {
8334 #ifdef OBJ_ELF
8335   reloc_type code;
8336 #endif
8337   struct hppa_fix_struct *hppa_fix;
8338
8339   hppa_fix = (struct hppa_fix_struct *) fixp->tc_fix_data;
8340
8341 #ifdef OBJ_ELF
8342   /* LR/RR selectors are implicitly used for a number of different relocation
8343      types.  We must ensure that none of these types are adjusted (see below)
8344      even if they occur with a different selector.  */
8345   code = elf_hppa_reloc_final_type (stdoutput, fixp->fx_r_type,
8346                                     hppa_fix->fx_r_format,
8347                                     hppa_fix->fx_r_field);
8348
8349   switch (code)
8350     {
8351     /* Relocation types which use e_lrsel.  */
8352     case R_PARISC_DIR21L:
8353     case R_PARISC_DLTREL21L:
8354     case R_PARISC_DPREL21L:
8355     case R_PARISC_PLTOFF21L:
8356
8357     /* Relocation types which use e_rrsel.  */
8358     case R_PARISC_DIR14R:
8359     case R_PARISC_DIR14DR:
8360     case R_PARISC_DIR14WR:
8361     case R_PARISC_DIR17R:
8362     case R_PARISC_DLTREL14R:
8363     case R_PARISC_DLTREL14DR:
8364     case R_PARISC_DLTREL14WR:
8365     case R_PARISC_DPREL14R:
8366     case R_PARISC_DPREL14DR:
8367     case R_PARISC_DPREL14WR:
8368     case R_PARISC_PLTOFF14R:
8369     case R_PARISC_PLTOFF14DR:
8370     case R_PARISC_PLTOFF14WR:
8371
8372     /* Other types that we reject for reduction.  */
8373     case R_PARISC_GNU_VTENTRY:
8374     case R_PARISC_GNU_VTINHERIT:
8375       return 0;
8376     default:
8377       break;
8378     }
8379 #endif
8380
8381   /* Reject reductions of symbols in sym1-sym2 expressions when
8382      the fixup will occur in a CODE subspace.
8383
8384      XXX FIXME: Long term we probably want to reject all of these;
8385      for example reducing in the debug section would lose if we ever
8386      supported using the optimizing hp linker.  */
8387   if (fixp->fx_addsy
8388       && fixp->fx_subsy
8389       && (hppa_fix->segment->flags & SEC_CODE))
8390     return 0;
8391
8392   /* We can't adjust any relocs that use LR% and RR% field selectors.
8393
8394      If a symbol is reduced to a section symbol, the assembler will
8395      adjust the addend unless the symbol happens to reside right at
8396      the start of the section.  Additionally, the linker has no choice
8397      but to manipulate the addends when coalescing input sections for
8398      "ld -r".  Since an LR% field selector is defined to round the
8399      addend, we can't change the addend without risking that a LR% and
8400      it's corresponding (possible multiple) RR% field will no longer
8401      sum to the right value.
8402
8403      eg. Suppose we have
8404      .          ldil    LR%foo+0,%r21
8405      .          ldw     RR%foo+0(%r21),%r26
8406      .          ldw     RR%foo+4(%r21),%r25
8407
8408      If foo is at address 4092 (decimal) in section `sect', then after
8409      reducing to the section symbol we get
8410      .                  LR%sect+4092 == (L%sect)+0
8411      .                  RR%sect+4092 == (R%sect)+4092
8412      .                  RR%sect+4096 == (R%sect)-4096
8413      and the last address loses because rounding the addend to 8k
8414      multiples takes us up to 8192 with an offset of -4096.
8415
8416      In cases where the LR% expression is identical to the RR% one we
8417      will never have a problem, but is so happens that gcc rounds
8418      addends involved in LR% field selectors to work around a HP
8419      linker bug.  ie. We often have addresses like the last case
8420      above where the LR% expression is offset from the RR% one.  */
8421
8422   if (hppa_fix->fx_r_field == e_lrsel
8423       || hppa_fix->fx_r_field == e_rrsel
8424       || hppa_fix->fx_r_field == e_nlrsel)
8425     return 0;
8426
8427   /* Reject reductions of symbols in DLT relative relocs,
8428      relocations with plabels.  */
8429   if (hppa_fix->fx_r_field == e_tsel
8430       || hppa_fix->fx_r_field == e_ltsel
8431       || hppa_fix->fx_r_field == e_rtsel
8432       || hppa_fix->fx_r_field == e_psel
8433       || hppa_fix->fx_r_field == e_rpsel
8434       || hppa_fix->fx_r_field == e_lpsel)
8435     return 0;
8436
8437   /* Reject absolute calls (jumps).  */
8438   if (hppa_fix->fx_r_type == R_HPPA_ABS_CALL)
8439     return 0;
8440
8441   /* Reject reductions of function symbols.  */
8442   if (fixp->fx_addsy != 0 && S_IS_FUNCTION (fixp->fx_addsy))
8443     return 0;
8444
8445   return 1;
8446 }
8447
8448 /* Return nonzero if the fixup in FIXP will require a relocation,
8449    even it if appears that the fixup could be completely handled
8450    within GAS.  */
8451
8452 int
8453 hppa_force_relocation (struct fix *fixp)
8454 {
8455   struct hppa_fix_struct *hppa_fixp;
8456
8457   hppa_fixp = (struct hppa_fix_struct *) fixp->tc_fix_data;
8458 #ifdef OBJ_SOM
8459   if (fixp->fx_r_type == (int) R_HPPA_ENTRY
8460       || fixp->fx_r_type == (int) R_HPPA_EXIT
8461       || fixp->fx_r_type == (int) R_HPPA_BEGIN_BRTAB
8462       || fixp->fx_r_type == (int) R_HPPA_END_BRTAB
8463       || fixp->fx_r_type == (int) R_HPPA_BEGIN_TRY
8464       || fixp->fx_r_type == (int) R_HPPA_END_TRY
8465       || (fixp->fx_addsy != NULL && fixp->fx_subsy != NULL
8466           && (hppa_fixp->segment->flags & SEC_CODE) != 0))
8467     return 1;
8468 #endif
8469 #ifdef OBJ_ELF
8470   if (fixp->fx_r_type == (int) R_PARISC_GNU_VTINHERIT
8471       || fixp->fx_r_type == (int) R_PARISC_GNU_VTENTRY)
8472     return 1;
8473 #endif
8474
8475   gas_assert (fixp->fx_addsy != NULL);
8476
8477   /* Ensure we emit a relocation for global symbols so that dynamic
8478      linking works.  */
8479   if (S_FORCE_RELOC (fixp->fx_addsy, 1))
8480     return 1;
8481
8482   /* It is necessary to force PC-relative calls/jumps to have a relocation
8483      entry if they're going to need either an argument relocation or long
8484      call stub.  */
8485   if (fixp->fx_pcrel
8486       && arg_reloc_stub_needed (symbol_arg_reloc_info (fixp->fx_addsy),
8487                                 hppa_fixp->fx_arg_reloc))
8488     return 1;
8489
8490   /* Now check to see if we're going to need a long-branch stub.  */
8491   if (fixp->fx_r_type == (int) R_HPPA_PCREL_CALL)
8492     {
8493       long pc = md_pcrel_from (fixp);
8494       valueT distance, min_stub_distance;
8495
8496       distance = fixp->fx_offset + S_GET_VALUE (fixp->fx_addsy) - pc - 8;
8497
8498       /* Distance to the closest possible stub.  This will detect most
8499          but not all circumstances where a stub will not work.  */
8500       min_stub_distance = pc + 16;
8501 #ifdef OBJ_SOM
8502       if (last_call_info != NULL)
8503         min_stub_distance -= S_GET_VALUE (last_call_info->start_symbol);
8504 #endif
8505
8506       if ((distance + 8388608 >= 16777216
8507            && min_stub_distance <= 8388608)
8508           || (hppa_fixp->fx_r_format == 17
8509               && distance + 262144 >= 524288
8510               && min_stub_distance <= 262144)
8511           || (hppa_fixp->fx_r_format == 12
8512               && distance + 8192 >= 16384
8513               && min_stub_distance <= 8192)
8514           )
8515         return 1;
8516     }
8517
8518   if (fixp->fx_r_type == (int) R_HPPA_ABS_CALL)
8519     return 1;
8520
8521   /* No need (yet) to force another relocations to be emitted.  */
8522   return 0;
8523 }
8524
8525 /* Now for some ELF specific code.  FIXME.  */
8526 #ifdef OBJ_ELF
8527 /* For ELF, this function serves one purpose:  to setup the st_size
8528    field of STT_FUNC symbols.  To do this, we need to scan the
8529    call_info structure list, determining st_size in by taking the
8530    difference in the address of the beginning/end marker symbols.  */
8531
8532 void
8533 elf_hppa_final_processing (void)
8534 {
8535   struct call_info *call_info_pointer;
8536
8537   for (call_info_pointer = call_info_root;
8538        call_info_pointer;
8539        call_info_pointer = call_info_pointer->ci_next)
8540     {
8541       elf_symbol_type *esym
8542         = ((elf_symbol_type *)
8543            symbol_get_bfdsym (call_info_pointer->start_symbol));
8544       esym->internal_elf_sym.st_size =
8545         S_GET_VALUE (call_info_pointer->end_symbol)
8546         - S_GET_VALUE (call_info_pointer->start_symbol) + 4;
8547     }
8548 }
8549
8550 static void
8551 pa_vtable_entry (int ignore ATTRIBUTE_UNUSED)
8552 {
8553   struct fix *new_fix;
8554
8555   new_fix = obj_elf_vtable_entry (0);
8556
8557   if (new_fix)
8558     {
8559       struct hppa_fix_struct * hppa_fix = obstack_alloc (&notes, sizeof (struct hppa_fix_struct));
8560
8561       hppa_fix->fx_r_type = R_HPPA;
8562       hppa_fix->fx_r_field = e_fsel;
8563       hppa_fix->fx_r_format = 32;
8564       hppa_fix->fx_arg_reloc = 0;
8565       hppa_fix->segment = now_seg;
8566       new_fix->tc_fix_data = (void *) hppa_fix;
8567       new_fix->fx_r_type = (int) R_PARISC_GNU_VTENTRY;
8568     }
8569 }
8570
8571 static void
8572 pa_vtable_inherit (int ignore ATTRIBUTE_UNUSED)
8573 {
8574   struct fix *new_fix;
8575
8576   new_fix = obj_elf_vtable_inherit (0);
8577
8578   if (new_fix)
8579     {
8580       struct hppa_fix_struct * hppa_fix = obstack_alloc (&notes, sizeof (struct hppa_fix_struct));
8581
8582       hppa_fix->fx_r_type = R_HPPA;
8583       hppa_fix->fx_r_field = e_fsel;
8584       hppa_fix->fx_r_format = 32;
8585       hppa_fix->fx_arg_reloc = 0;
8586       hppa_fix->segment = now_seg;
8587       new_fix->tc_fix_data = (void *) hppa_fix;
8588       new_fix->fx_r_type = (int) R_PARISC_GNU_VTINHERIT;
8589     }
8590 }
8591 #endif
8592
8593 /* Table of pseudo ops for the PA.  FIXME -- how many of these
8594    are now redundant with the overall GAS and the object file
8595    dependent tables?  */
8596 const pseudo_typeS md_pseudo_table[] =
8597 {
8598   /* align pseudo-ops on the PA specify the actual alignment requested,
8599      not the log2 of the requested alignment.  */
8600 #ifdef OBJ_SOM
8601   {"align", pa_align, 8},
8602 #endif
8603 #ifdef OBJ_ELF
8604   {"align", s_align_bytes, 8},
8605 #endif
8606   {"begin_brtab", pa_brtab, 1},
8607   {"begin_try", pa_try, 1},
8608   {"block", pa_block, 1},
8609   {"blockz", pa_block, 0},
8610   {"byte", pa_cons, 1},
8611   {"call", pa_call, 0},
8612   {"callinfo", pa_callinfo, 0},
8613 #if defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD))
8614   {"code", obj_elf_text, 0},
8615 #else
8616   {"code", pa_text, 0},
8617   {"comm", pa_comm, 0},
8618 #endif
8619 #ifdef OBJ_SOM
8620   {"compiler", pa_compiler, 0},
8621 #endif
8622   {"copyright", pa_copyright, 0},
8623 #if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
8624   {"data", pa_data, 0},
8625 #endif
8626   {"double", pa_float_cons, 'd'},
8627   {"dword", pa_cons, 8},
8628   {"end", pa_end, 0},
8629   {"end_brtab", pa_brtab, 0},
8630 #if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
8631   {"end_try", pa_try, 0},
8632 #endif
8633   {"enter", pa_enter, 0},
8634   {"entry", pa_entry, 0},
8635   {"equ", pa_equ, 0},
8636   {"exit", pa_exit, 0},
8637   {"export", pa_export, 0},
8638   {"fill", pa_fill, 0},
8639   {"float", pa_float_cons, 'f'},
8640   {"half", pa_cons, 2},
8641   {"import", pa_import, 0},
8642   {"int", pa_cons, 4},
8643   {"label", pa_label, 0},
8644   {"lcomm", pa_lcomm, 0},
8645   {"leave", pa_leave, 0},
8646   {"level", pa_level, 0},
8647   {"long", pa_cons, 4},
8648   {"lsym", pa_lsym, 0},
8649 #ifdef OBJ_SOM
8650   {"nsubspa", pa_subspace, 1},
8651 #endif
8652   {"octa", pa_cons, 16},
8653   {"org", pa_origin, 0},
8654   {"origin", pa_origin, 0},
8655   {"param", pa_param, 0},
8656   {"proc", pa_proc, 0},
8657   {"procend", pa_procend, 0},
8658   {"quad", pa_cons, 8},
8659   {"reg", pa_equ, 1},
8660   {"short", pa_cons, 2},
8661   {"single", pa_float_cons, 'f'},
8662 #ifdef OBJ_SOM
8663   {"space", pa_space, 0},
8664   {"spnum", pa_spnum, 0},
8665 #endif
8666   {"string", pa_stringer, 0},
8667   {"stringz", pa_stringer, 1},
8668 #ifdef OBJ_SOM
8669   {"subspa", pa_subspace, 0},
8670 #endif
8671 #if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
8672   {"text", pa_text, 0},
8673 #endif
8674   {"version", pa_version, 0},
8675 #ifdef OBJ_ELF
8676   {"vtable_entry", pa_vtable_entry, 0},
8677   {"vtable_inherit", pa_vtable_inherit, 0},
8678 #endif
8679   {"word", pa_cons, 4},
8680   {NULL, 0, 0}
8681 };
8682
8683 #ifdef OBJ_ELF
8684 void
8685 hppa_cfi_frame_initial_instructions (void)
8686 {
8687   cfi_add_CFA_def_cfa (30, 0);
8688 }
8689
8690 int
8691 hppa_regname_to_dw2regnum (char *regname)
8692 {
8693   unsigned int regnum = -1;
8694   unsigned int i;
8695   const char *p;
8696   char *q;
8697   static struct { char *name; int dw2regnum; } regnames[] =
8698     {
8699       { "sp", 30 }, { "rp", 2 },
8700     };
8701
8702   for (i = 0; i < ARRAY_SIZE (regnames); ++i)
8703     if (strcmp (regnames[i].name, regname) == 0)
8704       return regnames[i].dw2regnum;
8705
8706   if (regname[0] == 'r')
8707     {
8708       p = regname + 1;
8709       regnum = strtoul (p, &q, 10);
8710       if (p == q || *q || regnum >= 32)
8711         return -1;
8712     }
8713   else if (regname[0] == 'f' && regname[1] == 'r')
8714     {
8715       p = regname + 2;
8716       regnum = strtoul (p, &q, 10);
8717 #if TARGET_ARCH_SIZE == 64
8718       if (p == q || *q || regnum <= 4 || regnum >= 32)
8719         return -1;
8720       regnum += 32 - 4;
8721 #else
8722       if (p == q
8723           || (*q  && ((*q != 'L' && *q != 'R') || *(q + 1)))
8724           || regnum <= 4 || regnum >= 32)
8725         return -1;
8726       regnum = (regnum - 4) * 2 + 32;
8727       if (*q == 'R')
8728         regnum++;
8729 #endif
8730     }
8731   return regnum;
8732 }
8733 #endif