gas/config/tc-hppa.c

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