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