gas/config/tc-hppa.c

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