gas/config/tc-hppa.c

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