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, 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, 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   /* Always fill with zeros, that's what the HP assembler does.  */
5955   temp_fill = 0;
5956
5957   p = frag_var (rs_fill, (int) temp_size, (int) temp_size,
5958                 (relax_substateT) 0, (symbolS *) 0, (offsetT) 1, NULL);
5959   memset (p, 0, temp_size);
5960
5961   /* Convert 2 bytes at a time.  */
5962
5963   for (i = 0; i < temp_size; i += 2)
5964     {
5965       md_number_to_chars (p + i,
5966                           (valueT) temp_fill,
5967                           (int) ((temp_size - i) > 2 ? 2 : (temp_size - i)));
5968     }
5969
5970   pa_undefine_label ();
5971   demand_empty_rest_of_line ();
5972 }
5973
5974 /* Handle a .begin_brtab and .end_brtab pseudo-op.  */
5975
5976 static void
5977 pa_brtab (begin)
5978      int begin ATTRIBUTE_UNUSED;
5979 {
5980
5981 #ifdef OBJ_SOM
5982   /* The BRTAB relocations are only available in SOM (to denote
5983      the beginning and end of branch tables).  */
5984   char *where = frag_more (0);
5985
5986   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
5987                 NULL, (offsetT) 0, NULL,
5988                 0, begin ? R_HPPA_BEGIN_BRTAB : R_HPPA_END_BRTAB,
5989                 e_fsel, 0, 0, 0);
5990 #endif
5991
5992   demand_empty_rest_of_line ();
5993 }
5994
5995 /* Handle a .begin_try and .end_try pseudo-op.  */
5996
5997 static void
5998 pa_try (begin)
5999      int begin ATTRIBUTE_UNUSED;
6000 {
6001 #ifdef OBJ_SOM
6002   expressionS exp;
6003   char *where = frag_more (0);
6004
6005   if (! begin)
6006     expression (&exp);
6007
6008   /* The TRY relocations are only available in SOM (to denote
6009      the beginning and end of exception handling regions).  */
6010
6011   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6012                 NULL, (offsetT) 0, begin ? NULL : &exp,
6013                 0, begin ? R_HPPA_BEGIN_TRY : R_HPPA_END_TRY,
6014                 e_fsel, 0, 0, 0);
6015 #endif
6016
6017   demand_empty_rest_of_line ();
6018 }
6019
6020 /* Handle a .CALL pseudo-op.  This involves storing away information
6021    about where arguments are to be found so the linker can detect
6022    (and correct) argument location mismatches between caller and callee.  */
6023
6024 static void
6025 pa_call (unused)
6026      int unused ATTRIBUTE_UNUSED;
6027 {
6028 #ifdef OBJ_SOM
6029   /* We must have a valid space and subspace.  */
6030   pa_check_current_space_and_subspace ();
6031 #endif
6032
6033   pa_call_args (&last_call_desc);
6034   demand_empty_rest_of_line ();
6035 }
6036
6037 /* Do the dirty work of building a call descriptor which describes
6038    where the caller placed arguments to a function call.  */
6039
6040 static void
6041 pa_call_args (call_desc)
6042      struct call_desc *call_desc;
6043 {
6044   char *name, c, *p;
6045   unsigned int temp, arg_reloc;
6046
6047   while (!is_end_of_statement ())
6048     {
6049       name = input_line_pointer;
6050       c = get_symbol_end ();
6051       /* Process a source argument.  */
6052       if ((strncasecmp (name, "argw", 4) == 0))
6053         {
6054           temp = atoi (name + 4);
6055           p = input_line_pointer;
6056           *p = c;
6057           input_line_pointer++;
6058           name = input_line_pointer;
6059           c = get_symbol_end ();
6060           arg_reloc = pa_build_arg_reloc (name);
6061           call_desc->arg_reloc |= pa_align_arg_reloc (temp, arg_reloc);
6062         }
6063       /* Process a return value.  */
6064       else if ((strncasecmp (name, "rtnval", 6) == 0))
6065         {
6066           p = input_line_pointer;
6067           *p = c;
6068           input_line_pointer++;
6069           name = input_line_pointer;
6070           c = get_symbol_end ();
6071           arg_reloc = pa_build_arg_reloc (name);
6072           call_desc->arg_reloc |= (arg_reloc & 0x3);
6073         }
6074       else
6075         {
6076           as_bad (_("Invalid .CALL argument: %s"), name);
6077         }
6078       p = input_line_pointer;
6079       *p = c;
6080       if (!is_end_of_statement ())
6081         input_line_pointer++;
6082     }
6083 }
6084
6085 /* Return TRUE if FRAG1 and FRAG2 are the same.  */
6086
6087 static int
6088 is_same_frag (frag1, frag2)
6089      fragS *frag1;
6090      fragS *frag2;
6091 {
6092
6093   if (frag1 == NULL)
6094     return (FALSE);
6095   else if (frag2 == NULL)
6096     return (FALSE);
6097   else if (frag1 == frag2)
6098     return (TRUE);
6099   else if (frag2->fr_type == rs_fill && frag2->fr_fix == 0)
6100     return (is_same_frag (frag1, frag2->fr_next));
6101   else
6102     return (FALSE);
6103 }
6104
6105 #ifdef OBJ_ELF
6106 /* Build an entry in the UNWIND subspace from the given function
6107    attributes in CALL_INFO.  This is not needed for SOM as using
6108    R_ENTRY and R_EXIT relocations allow the linker to handle building
6109    of the unwind spaces.  */
6110
6111 static void
6112 pa_build_unwind_subspace (call_info)
6113      struct call_info *call_info;
6114 {
6115   asection *seg, *save_seg;
6116   subsegT save_subseg;
6117   unsigned int unwind;
6118   int reloc;
6119   char *p;
6120
6121   if ((bfd_get_section_flags (stdoutput, now_seg)
6122        & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
6123       != (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
6124     return;
6125
6126   reloc = R_PARISC_SEGREL32;
6127   save_seg = now_seg;
6128   save_subseg = now_subseg;
6129   /* Get into the right seg/subseg.  This may involve creating
6130      the seg the first time through.  Make sure to have the
6131      old seg/subseg so that we can reset things when we are done.  */
6132   seg = bfd_get_section_by_name (stdoutput, UNWIND_SECTION_NAME);
6133   if (seg == ASEC_NULL)
6134     {
6135       seg = subseg_new (UNWIND_SECTION_NAME, 0);
6136       bfd_set_section_flags (stdoutput, seg,
6137                              SEC_READONLY | SEC_HAS_CONTENTS
6138                              | SEC_LOAD | SEC_RELOC | SEC_ALLOC | SEC_DATA);
6139       bfd_set_section_alignment (stdoutput, seg, 2);
6140     }
6141
6142   subseg_set (seg, 0);
6143
6144   /* Get some space to hold relocation information for the unwind
6145      descriptor.  */
6146   p = frag_more (16);
6147
6148   /* Relocation info. for start offset of the function.  */
6149   md_number_to_chars (p, 0, 4);
6150   fix_new_hppa (frag_now, p - frag_now->fr_literal, 4,
6151                 call_info->start_symbol, (offsetT) 0,
6152                 (expressionS *) NULL, 0, reloc,
6153                 e_fsel, 32, 0, 0);
6154
6155   /* Relocation info. for end offset of the function.
6156
6157      Because we allow reductions of 32bit relocations for ELF, this will be
6158      reduced to section_sym + offset which avoids putting the temporary
6159      symbol into the symbol table.  It (should) end up giving the same
6160      value as call_info->start_symbol + function size once the linker is
6161      finished with its work.  */
6162   md_number_to_chars (p + 4, 0, 4);
6163   fix_new_hppa (frag_now, p + 4 - frag_now->fr_literal, 4,
6164                 call_info->end_symbol, (offsetT) 0,
6165                 (expressionS *) NULL, 0, reloc,
6166                 e_fsel, 32, 0, 0);
6167
6168   /* Dump the descriptor.  */
6169   unwind = UNWIND_LOW32 (&call_info->ci_unwind.descriptor);
6170   md_number_to_chars (p + 8, unwind, 4);
6171
6172   unwind = UNWIND_HIGH32 (&call_info->ci_unwind.descriptor);
6173   md_number_to_chars (p + 12, unwind, 4);
6174
6175   /* Return back to the original segment/subsegment.  */
6176   subseg_set (save_seg, save_subseg);
6177 }
6178 #endif
6179
6180 /* Process a .CALLINFO pseudo-op.  This information is used later
6181    to build unwind descriptors and maybe one day to support
6182    .ENTER and .LEAVE.  */
6183
6184 static void
6185 pa_callinfo (unused)
6186      int unused ATTRIBUTE_UNUSED;
6187 {
6188   char *name, c, *p;
6189   int temp;
6190
6191 #ifdef OBJ_SOM
6192   /* We must have a valid space and subspace.  */
6193   pa_check_current_space_and_subspace ();
6194 #endif
6195
6196   /* .CALLINFO must appear within a procedure definition.  */
6197   if (!within_procedure)
6198     as_bad (_(".callinfo is not within a procedure definition"));
6199
6200   /* Mark the fact that we found the .CALLINFO for the
6201      current procedure.  */
6202   callinfo_found = TRUE;
6203
6204   /* Iterate over the .CALLINFO arguments.  */
6205   while (!is_end_of_statement ())
6206     {
6207       name = input_line_pointer;
6208       c = get_symbol_end ();
6209       /* Frame size specification.  */
6210       if ((strncasecmp (name, "frame", 5) == 0))
6211         {
6212           p = input_line_pointer;
6213           *p = c;
6214           input_line_pointer++;
6215           temp = get_absolute_expression ();
6216           if ((temp & 0x3) != 0)
6217             {
6218               as_bad (_("FRAME parameter must be a multiple of 8: %d\n"), temp);
6219               temp = 0;
6220             }
6221
6222           /* callinfo is in bytes and unwind_desc is in 8 byte units.  */
6223           last_call_info->ci_unwind.descriptor.frame_size = temp / 8;
6224
6225         }
6226       /* Entry register (GR, GR and SR) specifications.  */
6227       else if ((strncasecmp (name, "entry_gr", 8) == 0))
6228         {
6229           p = input_line_pointer;
6230           *p = c;
6231           input_line_pointer++;
6232           temp = get_absolute_expression ();
6233           /* The HP assembler accepts 19 as the high bound for ENTRY_GR
6234              even though %r19 is caller saved.  I think this is a bug in
6235              the HP assembler, and we are not going to emulate it.  */
6236           if (temp < 3 || temp > 18)
6237             as_bad (_("Value for ENTRY_GR must be in the range 3..18\n"));
6238           last_call_info->ci_unwind.descriptor.entry_gr = temp - 2;
6239         }
6240       else if ((strncasecmp (name, "entry_fr", 8) == 0))
6241         {
6242           p = input_line_pointer;
6243           *p = c;
6244           input_line_pointer++;
6245           temp = get_absolute_expression ();
6246           /* Similarly the HP assembler takes 31 as the high bound even
6247              though %fr21 is the last callee saved floating point register.  */
6248           if (temp < 12 || temp > 21)
6249             as_bad (_("Value for ENTRY_FR must be in the range 12..21\n"));
6250           last_call_info->ci_unwind.descriptor.entry_fr = temp - 11;
6251         }
6252       else if ((strncasecmp (name, "entry_sr", 8) == 0))
6253         {
6254           p = input_line_pointer;
6255           *p = c;
6256           input_line_pointer++;
6257           temp = get_absolute_expression ();
6258           if (temp != 3)
6259             as_bad (_("Value for ENTRY_SR must be 3\n"));
6260         }
6261       /* Note whether or not this function performs any calls.  */
6262       else if ((strncasecmp (name, "calls", 5) == 0) ||
6263                (strncasecmp (name, "caller", 6) == 0))
6264         {
6265           p = input_line_pointer;
6266           *p = c;
6267         }
6268       else if ((strncasecmp (name, "no_calls", 8) == 0))
6269         {
6270           p = input_line_pointer;
6271           *p = c;
6272         }
6273       /* Should RP be saved into the stack.  */
6274       else if ((strncasecmp (name, "save_rp", 7) == 0))
6275         {
6276           p = input_line_pointer;
6277           *p = c;
6278           last_call_info->ci_unwind.descriptor.save_rp = 1;
6279         }
6280       /* Likewise for SP.  */
6281       else if ((strncasecmp (name, "save_sp", 7) == 0))
6282         {
6283           p = input_line_pointer;
6284           *p = c;
6285           last_call_info->ci_unwind.descriptor.save_sp = 1;
6286         }
6287       /* Is this an unwindable procedure.  If so mark it so
6288          in the unwind descriptor.  */
6289       else if ((strncasecmp (name, "no_unwind", 9) == 0))
6290         {
6291           p = input_line_pointer;
6292           *p = c;
6293           last_call_info->ci_unwind.descriptor.cannot_unwind = 1;
6294         }
6295       /* Is this an interrupt routine.  If so mark it in the
6296          unwind descriptor.  */
6297       else if ((strncasecmp (name, "hpux_int", 7) == 0))
6298         {
6299           p = input_line_pointer;
6300           *p = c;
6301           last_call_info->ci_unwind.descriptor.hpux_interrupt_marker = 1;
6302         }
6303       /* Is this a millicode routine.  "millicode" isn't in my
6304          assembler manual, but my copy is old.  The HP assembler
6305          accepts it, and there's a place in the unwind descriptor
6306          to drop the information, so we'll accept it too.  */
6307       else if ((strncasecmp (name, "millicode", 9) == 0))
6308         {
6309           p = input_line_pointer;
6310           *p = c;
6311           last_call_info->ci_unwind.descriptor.millicode = 1;
6312         }
6313       else
6314         {
6315           as_bad (_("Invalid .CALLINFO argument: %s"), name);
6316           *input_line_pointer = c;
6317         }
6318       if (!is_end_of_statement ())
6319         input_line_pointer++;
6320     }
6321
6322   demand_empty_rest_of_line ();
6323 }
6324
6325 #if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
6326 /* Switch to the text space.  Like s_text, but delete our
6327    label when finished.  */
6328 static void
6329 pa_text (unused)
6330      int unused ATTRIBUTE_UNUSED;
6331 {
6332 #ifdef OBJ_SOM
6333   current_space = is_defined_space ("$TEXT$");
6334   current_subspace
6335     = pa_subsegment_to_subspace (current_space->sd_seg, 0);
6336 #endif
6337
6338   s_text (0);
6339   pa_undefine_label ();
6340 }
6341
6342 /* Switch to the data space.  As usual delete our label.  */
6343 static void
6344 pa_data (unused)
6345      int unused ATTRIBUTE_UNUSED;
6346 {
6347 #ifdef OBJ_SOM
6348   current_space = is_defined_space ("$PRIVATE$");
6349   current_subspace
6350     = pa_subsegment_to_subspace (current_space->sd_seg, 0);
6351 #endif
6352   s_data (0);
6353   pa_undefine_label ();
6354 }
6355
6356 /* This is different than the standard GAS s_comm(). On HP9000/800 machines,
6357    the .comm pseudo-op has the following symtax:
6358
6359    <label> .comm <length>
6360
6361    where <label> is optional and is a symbol whose address will be the start of
6362    a block of memory <length> bytes long. <length> must be an absolute
6363    expression.  <length> bytes will be allocated in the current space
6364    and subspace.
6365
6366    Also note the label may not even be on the same line as the .comm.
6367
6368    This difference in syntax means the colon function will be called
6369    on the symbol before we arrive in pa_comm.  colon will set a number
6370    of attributes of the symbol that need to be fixed here.  In particular
6371    the value, section pointer, fragment pointer, flags, etc.  What
6372    a pain.
6373
6374    This also makes error detection all but impossible.  */
6375
6376 static void
6377 pa_comm (unused)
6378      int unused ATTRIBUTE_UNUSED;
6379 {
6380   unsigned int size;
6381   symbolS *symbol;
6382   label_symbol_struct *label_symbol = pa_get_label ();
6383
6384   if (label_symbol)
6385     symbol = label_symbol->lss_label;
6386   else
6387     symbol = NULL;
6388
6389   SKIP_WHITESPACE ();
6390   size = get_absolute_expression ();
6391
6392   if (symbol)
6393     {
6394       symbol_get_bfdsym (symbol)->flags |= BSF_OBJECT;
6395       S_SET_VALUE (symbol, size);
6396       S_SET_SEGMENT (symbol, bfd_und_section_ptr);
6397       S_SET_EXTERNAL (symbol);
6398
6399       /* colon() has already set the frag to the current location in the
6400          current subspace; we need to reset the fragment to the zero address
6401          fragment.  We also need to reset the segment pointer.  */
6402       symbol_set_frag (symbol, &zero_address_frag);
6403     }
6404   demand_empty_rest_of_line ();
6405 }
6406 #endif /* !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD))) */
6407
6408 /* Process a .END pseudo-op.  */
6409
6410 static void
6411 pa_end (unused)
6412      int unused ATTRIBUTE_UNUSED;
6413 {
6414   demand_empty_rest_of_line ();
6415 }
6416
6417 /* Process a .ENTER pseudo-op.  This is not supported.  */
6418 static void
6419 pa_enter (unused)
6420      int unused ATTRIBUTE_UNUSED;
6421 {
6422 #ifdef OBJ_SOM
6423   /* We must have a valid space and subspace.  */
6424   pa_check_current_space_and_subspace ();
6425 #endif
6426
6427   as_bad (_("The .ENTER pseudo-op is not supported"));
6428   demand_empty_rest_of_line ();
6429 }
6430
6431 /* Process a .ENTRY pseudo-op.  .ENTRY marks the beginning of the
6432    procedure.  */
6433 static void
6434 pa_entry (unused)
6435      int unused ATTRIBUTE_UNUSED;
6436 {
6437 #ifdef OBJ_SOM
6438   /* We must have a valid space and subspace.  */
6439   pa_check_current_space_and_subspace ();
6440 #endif
6441
6442   if (!within_procedure)
6443     as_bad (_("Misplaced .entry. Ignored."));
6444   else
6445     {
6446       if (!callinfo_found)
6447         as_bad (_("Missing .callinfo."));
6448     }
6449   demand_empty_rest_of_line ();
6450   within_entry_exit = TRUE;
6451
6452 #ifdef OBJ_SOM
6453   /* SOM defers building of unwind descriptors until the link phase.
6454      The assembler is responsible for creating an R_ENTRY relocation
6455      to mark the beginning of a region and hold the unwind bits, and
6456      for creating an R_EXIT relocation to mark the end of the region.
6457
6458      FIXME.  ELF should be using the same conventions!  The problem
6459      is an unwind requires too much relocation space.  Hmmm.  Maybe
6460      if we split the unwind bits up between the relocations which
6461      denote the entry and exit points.  */
6462   if (last_call_info->start_symbol != NULL)
6463     {
6464       char *where;
6465       unsigned int u;
6466
6467       where = frag_more (0);
6468       u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
6469       fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6470                     NULL, (offsetT) 0, NULL,
6471                     0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
6472     }
6473 #endif
6474 }
6475
6476 /* Silly nonsense for pa_equ.  The only half-sensible use for this is
6477    being able to subtract two register symbols that specify a range of
6478    registers, to get the size of the range.  */
6479 static int fudge_reg_expressions;
6480
6481 int
6482 hppa_force_reg_syms_absolute (resultP, op, rightP)
6483      expressionS *resultP;
6484      operatorT op ATTRIBUTE_UNUSED;
6485      expressionS *rightP;
6486 {
6487   if (fudge_reg_expressions
6488       && rightP->X_op == O_register
6489       && resultP->X_op == O_register)
6490     {
6491       rightP->X_op = O_constant;
6492       resultP->X_op = O_constant;
6493     }
6494   return 0;  /* Continue normal expr handling.  */
6495 }
6496
6497 /* Handle a .EQU pseudo-op.  */
6498
6499 static void
6500 pa_equ (reg)
6501      int reg;
6502 {
6503   label_symbol_struct *label_symbol = pa_get_label ();
6504   symbolS *symbol;
6505
6506   if (label_symbol)
6507     {
6508       symbol = label_symbol->lss_label;
6509       if (reg)
6510         {
6511           strict = 1;
6512           if (!pa_parse_number (&input_line_pointer, 0))
6513             as_bad (_(".REG expression must be a register"));
6514           S_SET_VALUE (symbol, pa_number);
6515           S_SET_SEGMENT (symbol, reg_section);
6516         }
6517       else
6518         {
6519           expressionS exp;
6520           segT seg;
6521
6522           fudge_reg_expressions = 1;
6523           seg = expression (&exp);
6524           fudge_reg_expressions = 0;
6525           if (exp.X_op != O_constant
6526               && exp.X_op != O_register)
6527             {
6528               if (exp.X_op != O_absent)
6529                 as_bad (_("bad or irreducible absolute expression; zero assumed"));
6530               exp.X_add_number = 0;
6531               seg = absolute_section;
6532             }
6533           S_SET_VALUE (symbol, (unsigned int) exp.X_add_number);
6534           S_SET_SEGMENT (symbol, seg);
6535         }
6536     }
6537   else
6538     {
6539       if (reg)
6540         as_bad (_(".REG must use a label"));
6541       else
6542         as_bad (_(".EQU must use a label"));
6543     }
6544
6545   pa_undefine_label ();
6546   demand_empty_rest_of_line ();
6547 }
6548
6549 /* Helper function.  Does processing for the end of a function.  This
6550    usually involves creating some relocations or building special
6551    symbols to mark the end of the function.  */
6552
6553 static void
6554 process_exit ()
6555 {
6556   char *where;
6557
6558   where = frag_more (0);
6559
6560 #ifdef OBJ_ELF
6561   /* Mark the end of the function, stuff away the location of the frag
6562      for the end of the function, and finally call pa_build_unwind_subspace
6563      to add an entry in the unwind table.  */
6564   hppa_elf_mark_end_of_function ();
6565   pa_build_unwind_subspace (last_call_info);
6566 #else
6567   /* SOM defers building of unwind descriptors until the link phase.
6568      The assembler is responsible for creating an R_ENTRY relocation
6569      to mark the beginning of a region and hold the unwind bits, and
6570      for creating an R_EXIT relocation to mark the end of the region.
6571
6572      FIXME.  ELF should be using the same conventions!  The problem
6573      is an unwind requires too much relocation space.  Hmmm.  Maybe
6574      if we split the unwind bits up between the relocations which
6575      denote the entry and exit points.  */
6576   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6577                 NULL, (offsetT) 0,
6578                 NULL, 0, R_HPPA_EXIT, e_fsel, 0, 0,
6579                 UNWIND_HIGH32 (&last_call_info->ci_unwind.descriptor));
6580 #endif
6581 }
6582
6583 /* Process a .EXIT pseudo-op.  */
6584
6585 static void
6586 pa_exit (unused)
6587      int unused ATTRIBUTE_UNUSED;
6588 {
6589 #ifdef OBJ_SOM
6590   /* We must have a valid space and subspace.  */
6591   pa_check_current_space_and_subspace ();
6592 #endif
6593
6594   if (!within_procedure)
6595     as_bad (_(".EXIT must appear within a procedure"));
6596   else
6597     {
6598       if (!callinfo_found)
6599         as_bad (_("Missing .callinfo"));
6600       else
6601         {
6602           if (!within_entry_exit)
6603             as_bad (_("No .ENTRY for this .EXIT"));
6604           else
6605             {
6606               within_entry_exit = FALSE;
6607               process_exit ();
6608             }
6609         }
6610     }
6611   demand_empty_rest_of_line ();
6612 }
6613
6614 /* Process a .EXPORT directive.  This makes functions external
6615    and provides information such as argument relocation entries
6616    to callers.  */
6617
6618 static void
6619 pa_export (unused)
6620      int unused ATTRIBUTE_UNUSED;
6621 {
6622   char *name, c, *p;
6623   symbolS *symbol;
6624
6625   name = input_line_pointer;
6626   c = get_symbol_end ();
6627   /* Make sure the given symbol exists.  */
6628   if ((symbol = symbol_find_or_make (name)) == NULL)
6629     {
6630       as_bad (_("Cannot define export symbol: %s\n"), name);
6631       p = input_line_pointer;
6632       *p = c;
6633       input_line_pointer++;
6634     }
6635   else
6636     {
6637       /* OK.  Set the external bits and process argument relocations.
6638          For the HP, weak and global are not mutually exclusive.
6639          S_SET_EXTERNAL will not set BSF_GLOBAL if WEAK is set.
6640          Call S_SET_EXTERNAL to get the other processing.  Manually
6641          set BSF_GLOBAL when we get back.  */
6642       S_SET_EXTERNAL (symbol);
6643       symbol_get_bfdsym (symbol)->flags |= BSF_GLOBAL;
6644       p = input_line_pointer;
6645       *p = c;
6646       if (!is_end_of_statement ())
6647         {
6648           input_line_pointer++;
6649           pa_type_args (symbol, 1);
6650         }
6651     }
6652
6653   demand_empty_rest_of_line ();
6654 }
6655
6656 /* Helper function to process arguments to a .EXPORT pseudo-op.  */
6657
6658 static void
6659 pa_type_args (symbolP, is_export)
6660      symbolS *symbolP;
6661      int is_export;
6662 {
6663   char *name, c, *p;
6664   unsigned int temp, arg_reloc;
6665   pa_symbol_type type = SYMBOL_TYPE_UNKNOWN;
6666   asymbol *bfdsym = symbol_get_bfdsym (symbolP);
6667
6668   if (strncasecmp (input_line_pointer, "absolute", 8) == 0)
6669
6670     {
6671       input_line_pointer += 8;
6672       bfdsym->flags &= ~BSF_FUNCTION;
6673       S_SET_SEGMENT (symbolP, bfd_abs_section_ptr);
6674       type = SYMBOL_TYPE_ABSOLUTE;
6675     }
6676   else if (strncasecmp (input_line_pointer, "code", 4) == 0)
6677     {
6678       input_line_pointer += 4;
6679       /* IMPORTing/EXPORTing CODE types for functions is meaningless for SOM,
6680          instead one should be IMPORTing/EXPORTing ENTRY types.
6681
6682          Complain if one tries to EXPORT a CODE type since that's never
6683          done.  Both GCC and HP C still try to IMPORT CODE types, so
6684          silently fix them to be ENTRY types.  */
6685       if (S_IS_FUNCTION (symbolP))
6686         {
6687           if (is_export)
6688             as_tsktsk (_("Using ENTRY rather than CODE in export directive for %s"),
6689                        S_GET_NAME (symbolP));
6690
6691           bfdsym->flags |= BSF_FUNCTION;
6692           type = SYMBOL_TYPE_ENTRY;
6693         }
6694       else
6695         {
6696           bfdsym->flags &= ~BSF_FUNCTION;
6697           type = SYMBOL_TYPE_CODE;
6698         }
6699     }
6700   else if (strncasecmp (input_line_pointer, "data", 4) == 0)
6701     {
6702       input_line_pointer += 4;
6703       bfdsym->flags &= ~BSF_FUNCTION;
6704       bfdsym->flags |= BSF_OBJECT;
6705       type = SYMBOL_TYPE_DATA;
6706     }
6707   else if ((strncasecmp (input_line_pointer, "entry", 5) == 0))
6708     {
6709       input_line_pointer += 5;
6710       bfdsym->flags |= BSF_FUNCTION;
6711       type = SYMBOL_TYPE_ENTRY;
6712     }
6713   else if (strncasecmp (input_line_pointer, "millicode", 9) == 0)
6714     {
6715       input_line_pointer += 9;
6716       bfdsym->flags |= BSF_FUNCTION;
6717 #ifdef OBJ_ELF
6718       {
6719         elf_symbol_type *elfsym = (elf_symbol_type *) bfdsym;
6720         elfsym->internal_elf_sym.st_info =
6721           ELF_ST_INFO (ELF_ST_BIND (elfsym->internal_elf_sym.st_info),
6722                        STT_PARISC_MILLI);
6723       }
6724 #endif
6725       type = SYMBOL_TYPE_MILLICODE;
6726     }
6727   else if (strncasecmp (input_line_pointer, "plabel", 6) == 0)
6728     {
6729       input_line_pointer += 6;
6730       bfdsym->flags &= ~BSF_FUNCTION;
6731       type = SYMBOL_TYPE_PLABEL;
6732     }
6733   else if (strncasecmp (input_line_pointer, "pri_prog", 8) == 0)
6734     {
6735       input_line_pointer += 8;
6736       bfdsym->flags |= BSF_FUNCTION;
6737       type = SYMBOL_TYPE_PRI_PROG;
6738     }
6739   else if (strncasecmp (input_line_pointer, "sec_prog", 8) == 0)
6740     {
6741       input_line_pointer += 8;
6742       bfdsym->flags |= BSF_FUNCTION;
6743       type = SYMBOL_TYPE_SEC_PROG;
6744     }
6745
6746   /* SOM requires much more information about symbol types
6747      than BFD understands.  This is how we get this information
6748      to the SOM BFD backend.  */
6749 #ifdef obj_set_symbol_type
6750   obj_set_symbol_type (bfdsym, (int) type);
6751 #endif
6752
6753   /* Now that the type of the exported symbol has been handled,
6754      handle any argument relocation information.  */
6755   while (!is_end_of_statement ())
6756     {
6757       if (*input_line_pointer == ',')
6758         input_line_pointer++;
6759       name = input_line_pointer;
6760       c = get_symbol_end ();
6761       /* Argument sources.  */
6762       if ((strncasecmp (name, "argw", 4) == 0))
6763         {
6764           p = input_line_pointer;
6765           *p = c;
6766           input_line_pointer++;
6767           temp = atoi (name + 4);
6768           name = input_line_pointer;
6769           c = get_symbol_end ();
6770           arg_reloc = pa_align_arg_reloc (temp, pa_build_arg_reloc (name));
6771 #if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
6772           symbol_arg_reloc_info (symbolP) |= arg_reloc;
6773 #endif
6774           *input_line_pointer = c;
6775         }
6776       /* The return value.  */
6777       else if ((strncasecmp (name, "rtnval", 6)) == 0)
6778         {
6779           p = input_line_pointer;
6780           *p = c;
6781           input_line_pointer++;
6782           name = input_line_pointer;
6783           c = get_symbol_end ();
6784           arg_reloc = pa_build_arg_reloc (name);
6785 #if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
6786           symbol_arg_reloc_info (symbolP) |= arg_reloc;
6787 #endif
6788           *input_line_pointer = c;
6789         }
6790       /* Privilege level.  */
6791       else if ((strncasecmp (name, "priv_lev", 8)) == 0)
6792         {
6793           p = input_line_pointer;
6794           *p = c;
6795           input_line_pointer++;
6796           temp = atoi (input_line_pointer);
6797 #ifdef OBJ_SOM
6798           ((obj_symbol_type *) bfdsym)->tc_data.ap.hppa_priv_level = temp;
6799 #endif
6800           c = get_symbol_end ();
6801           *input_line_pointer = c;
6802         }
6803       else
6804         {
6805           as_bad (_("Undefined .EXPORT/.IMPORT argument (ignored): %s"), name);
6806           p = input_line_pointer;
6807           *p = c;
6808         }
6809       if (!is_end_of_statement ())
6810         input_line_pointer++;
6811     }
6812 }
6813
6814 /* Handle an .IMPORT pseudo-op.  Any symbol referenced in a given
6815    assembly file must either be defined in the assembly file, or
6816    explicitly IMPORTED from another.  */
6817
6818 static void
6819 pa_import (unused)
6820      int unused ATTRIBUTE_UNUSED;
6821 {
6822   char *name, c, *p;
6823   symbolS *symbol;
6824
6825   name = input_line_pointer;
6826   c = get_symbol_end ();
6827
6828   symbol = symbol_find (name);
6829   /* Ugh.  We might be importing a symbol defined earlier in the file,
6830      in which case all the code below will really screw things up
6831      (set the wrong segment, symbol flags & type, etc).  */
6832   if (symbol == NULL || !S_IS_DEFINED (symbol))
6833     {
6834       symbol = symbol_find_or_make (name);
6835       p = input_line_pointer;
6836       *p = c;
6837
6838       if (!is_end_of_statement ())
6839         {
6840           input_line_pointer++;
6841           pa_type_args (symbol, 0);
6842         }
6843       else
6844         {
6845           /* Sigh.  To be compatible with the HP assembler and to help
6846              poorly written assembly code, we assign a type based on
6847              the current segment.  Note only BSF_FUNCTION really
6848              matters, we do not need to set the full SYMBOL_TYPE_* info.  */
6849           if (now_seg == text_section)
6850             symbol_get_bfdsym (symbol)->flags |= BSF_FUNCTION;
6851
6852           /* If the section is undefined, then the symbol is undefined
6853              Since this is an import, leave the section undefined.  */
6854           S_SET_SEGMENT (symbol, bfd_und_section_ptr);
6855         }
6856     }
6857   else
6858     {
6859       /* The symbol was already defined.  Just eat everything up to
6860          the end of the current statement.  */
6861       while (!is_end_of_statement ())
6862         input_line_pointer++;
6863     }
6864
6865   demand_empty_rest_of_line ();
6866 }
6867
6868 /* Handle a .LABEL pseudo-op.  */
6869
6870 static void
6871 pa_label (unused)
6872      int unused ATTRIBUTE_UNUSED;
6873 {
6874   char *name, c, *p;
6875
6876   name = input_line_pointer;
6877   c = get_symbol_end ();
6878
6879   if (strlen (name) > 0)
6880     {
6881       colon (name);
6882       p = input_line_pointer;
6883       *p = c;
6884     }
6885   else
6886     {
6887       as_warn (_("Missing label name on .LABEL"));
6888     }
6889
6890   if (!is_end_of_statement ())
6891     {
6892       as_warn (_("extra .LABEL arguments ignored."));
6893       ignore_rest_of_line ();
6894     }
6895   demand_empty_rest_of_line ();
6896 }
6897
6898 /* Handle a .LEAVE pseudo-op.  This is not supported yet.  */
6899
6900 static void
6901 pa_leave (unused)
6902      int unused ATTRIBUTE_UNUSED;
6903 {
6904 #ifdef OBJ_SOM
6905   /* We must have a valid space and subspace.  */
6906   pa_check_current_space_and_subspace ();
6907 #endif
6908
6909   as_bad (_("The .LEAVE pseudo-op is not supported"));
6910   demand_empty_rest_of_line ();
6911 }
6912
6913 /* Handle a .LEVEL pseudo-op.  */
6914
6915 static void
6916 pa_level (unused)
6917      int unused ATTRIBUTE_UNUSED;
6918 {
6919   char *level;
6920
6921   level = input_line_pointer;
6922   if (strncmp (level, "1.0", 3) == 0)
6923     {
6924       input_line_pointer += 3;
6925       if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 10))
6926         as_warn (_("could not set architecture and machine"));
6927     }
6928   else if (strncmp (level, "1.1", 3) == 0)
6929     {
6930       input_line_pointer += 3;
6931       if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 11))
6932         as_warn (_("could not set architecture and machine"));
6933     }
6934   else if (strncmp (level, "2.0w", 4) == 0)
6935     {
6936       input_line_pointer += 4;
6937       if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 25))
6938         as_warn (_("could not set architecture and machine"));
6939     }
6940   else if (strncmp (level, "2.0", 3) == 0)
6941     {
6942       input_line_pointer += 3;
6943       if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 20))
6944         as_warn (_("could not set architecture and machine"));
6945     }
6946   else
6947     {
6948       as_bad (_("Unrecognized .LEVEL argument\n"));
6949       ignore_rest_of_line ();
6950     }
6951   demand_empty_rest_of_line ();
6952 }
6953
6954 /* Handle a .ORIGIN pseudo-op.  */
6955
6956 static void
6957 pa_origin (unused)
6958      int unused ATTRIBUTE_UNUSED;
6959 {
6960 #ifdef OBJ_SOM
6961   /* We must have a valid space and subspace.  */
6962   pa_check_current_space_and_subspace ();
6963 #endif
6964
6965   s_org (0);
6966   pa_undefine_label ();
6967 }
6968
6969 /* Handle a .PARAM pseudo-op.  This is much like a .EXPORT, except it
6970    is for static functions.  FIXME.  Should share more code with .EXPORT.  */
6971
6972 static void
6973 pa_param (unused)
6974      int unused ATTRIBUTE_UNUSED;
6975 {
6976   char *name, c, *p;
6977   symbolS *symbol;
6978
6979   name = input_line_pointer;
6980   c = get_symbol_end ();
6981
6982   if ((symbol = symbol_find_or_make (name)) == NULL)
6983     {
6984       as_bad (_("Cannot define static symbol: %s\n"), name);
6985       p = input_line_pointer;
6986       *p = c;
6987       input_line_pointer++;
6988     }
6989   else
6990     {
6991       S_CLEAR_EXTERNAL (symbol);
6992       p = input_line_pointer;
6993       *p = c;
6994       if (!is_end_of_statement ())
6995         {
6996           input_line_pointer++;
6997           pa_type_args (symbol, 0);
6998         }
6999     }
7000
7001   demand_empty_rest_of_line ();
7002 }
7003
7004 /* Handle a .PROC pseudo-op.  It is used to mark the beginning
7005    of a procedure from a syntactical point of view.  */
7006
7007 static void
7008 pa_proc (unused)
7009      int unused ATTRIBUTE_UNUSED;
7010 {
7011   struct call_info *call_info;
7012
7013 #ifdef OBJ_SOM
7014   /* We must have a valid space and subspace.  */
7015   pa_check_current_space_and_subspace ();
7016 #endif
7017
7018   if (within_procedure)
7019     as_fatal (_("Nested procedures"));
7020
7021   /* Reset global variables for new procedure.  */
7022   callinfo_found = FALSE;
7023   within_procedure = TRUE;
7024
7025   /* Create another call_info structure.  */
7026   call_info = (struct call_info *) xmalloc (sizeof (struct call_info));
7027
7028   if (!call_info)
7029     as_fatal (_("Cannot allocate unwind descriptor\n"));
7030
7031   memset (call_info, 0, sizeof (struct call_info));
7032
7033   call_info->ci_next = NULL;
7034
7035   if (call_info_root == NULL)
7036     {
7037       call_info_root = call_info;
7038       last_call_info = call_info;
7039     }
7040   else
7041     {
7042       last_call_info->ci_next = call_info;
7043       last_call_info = call_info;
7044     }
7045
7046   /* set up defaults on call_info structure */
7047
7048   call_info->ci_unwind.descriptor.cannot_unwind = 0;
7049   call_info->ci_unwind.descriptor.region_desc = 1;
7050   call_info->ci_unwind.descriptor.hpux_interrupt_marker = 0;
7051
7052   /* If we got a .PROC pseudo-op, we know that the function is defined
7053      locally.  Make sure it gets into the symbol table.  */
7054   {
7055     label_symbol_struct *label_symbol = pa_get_label ();
7056
7057     if (label_symbol)
7058       {
7059         if (label_symbol->lss_label)
7060           {
7061             last_call_info->start_symbol = label_symbol->lss_label;
7062             symbol_get_bfdsym (label_symbol->lss_label)->flags |= BSF_FUNCTION;
7063           }
7064         else
7065           as_bad (_("Missing function name for .PROC (corrupted label chain)"));
7066       }
7067     else
7068       last_call_info->start_symbol = NULL;
7069   }
7070
7071   demand_empty_rest_of_line ();
7072 }
7073
7074 /* Process the syntactical end of a procedure.  Make sure all the
7075    appropriate pseudo-ops were found within the procedure.  */
7076
7077 static void
7078 pa_procend (unused)
7079      int unused ATTRIBUTE_UNUSED;
7080 {
7081
7082 #ifdef OBJ_SOM
7083   /* We must have a valid space and subspace.  */
7084   pa_check_current_space_and_subspace ();
7085 #endif
7086
7087   /* If we are within a procedure definition, make sure we've
7088      defined a label for the procedure; handle case where the
7089      label was defined after the .PROC directive.
7090
7091      Note there's not need to diddle with the segment or fragment
7092      for the label symbol in this case.  We have already switched
7093      into the new $CODE$ subspace at this point.  */
7094   if (within_procedure && last_call_info->start_symbol == NULL)
7095     {
7096       label_symbol_struct *label_symbol = pa_get_label ();
7097
7098       if (label_symbol)
7099         {
7100           if (label_symbol->lss_label)
7101             {
7102               last_call_info->start_symbol = label_symbol->lss_label;
7103               symbol_get_bfdsym (label_symbol->lss_label)->flags
7104                 |= BSF_FUNCTION;
7105 #ifdef OBJ_SOM
7106               /* Also handle allocation of a fixup to hold the unwind
7107                  information when the label appears after the proc/procend.  */
7108               if (within_entry_exit)
7109                 {
7110                   char *where;
7111                   unsigned int u;
7112
7113                   where = frag_more (0);
7114                   u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
7115                   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
7116                                 NULL, (offsetT) 0, NULL,
7117                                 0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
7118                 }
7119 #endif
7120             }
7121           else
7122             as_bad (_("Missing function name for .PROC (corrupted label chain)"));
7123         }
7124       else
7125         as_bad (_("Missing function name for .PROC"));
7126     }
7127
7128   if (!within_procedure)
7129     as_bad (_("misplaced .procend"));
7130
7131   if (!callinfo_found)
7132     as_bad (_("Missing .callinfo for this procedure"));
7133
7134   if (within_entry_exit)
7135     as_bad (_("Missing .EXIT for a .ENTRY"));
7136
7137 #ifdef OBJ_ELF
7138   /* ELF needs to mark the end of each function so that it can compute
7139      the size of the function (apparently its needed in the symbol table).  */
7140   hppa_elf_mark_end_of_function ();
7141 #endif
7142
7143   within_procedure = FALSE;
7144   demand_empty_rest_of_line ();
7145   pa_undefine_label ();
7146 }
7147
7148 #ifdef OBJ_SOM
7149 /* If VALUE is an exact power of two between zero and 2^31, then
7150    return log2 (VALUE).  Else return -1.  */
7151
7152 static int
7153 exact_log2 (value)
7154      int value;
7155 {
7156   int shift = 0;
7157
7158   while ((1 << shift) != value && shift < 32)
7159     shift++;
7160
7161   if (shift >= 32)
7162     return -1;
7163   else
7164     return shift;
7165 }
7166
7167 /* Check to make sure we have a valid space and subspace.  */
7168
7169 static void
7170 pa_check_current_space_and_subspace ()
7171 {
7172   if (current_space == NULL)
7173     as_fatal (_("Not in a space.\n"));
7174
7175   if (current_subspace == NULL)
7176     as_fatal (_("Not in a subspace.\n"));
7177 }
7178
7179 /* Parse the parameters to a .SPACE directive; if CREATE_FLAG is nonzero,
7180    then create a new space entry to hold the information specified
7181    by the parameters to the .SPACE directive.  */
7182
7183 static sd_chain_struct *
7184 pa_parse_space_stmt (space_name, create_flag)
7185      char *space_name;
7186      int create_flag;
7187 {
7188   char *name, *ptemp, c;
7189   char loadable, defined, private, sort;
7190   int spnum;
7191   asection *seg = NULL;
7192   sd_chain_struct *space;
7193
7194   /* load default values */
7195   spnum = 0;
7196   sort = 0;
7197   loadable = TRUE;
7198   defined = TRUE;
7199   private = FALSE;
7200   if (strcmp (space_name, "$TEXT$") == 0)
7201     {
7202       seg = pa_def_spaces[0].segment;
7203       defined = pa_def_spaces[0].defined;
7204       private = pa_def_spaces[0].private;
7205       sort = pa_def_spaces[0].sort;
7206       spnum = pa_def_spaces[0].spnum;
7207     }
7208   else if (strcmp (space_name, "$PRIVATE$") == 0)
7209     {
7210       seg = pa_def_spaces[1].segment;
7211       defined = pa_def_spaces[1].defined;
7212       private = pa_def_spaces[1].private;
7213       sort = pa_def_spaces[1].sort;
7214       spnum = pa_def_spaces[1].spnum;
7215     }
7216
7217   if (!is_end_of_statement ())
7218     {
7219       print_errors = FALSE;
7220       ptemp = input_line_pointer + 1;
7221       /* First see if the space was specified as a number rather than
7222          as a name.  According to the PA assembly manual the rest of
7223          the line should be ignored.  */
7224       strict = 0;
7225       pa_parse_number (&ptemp, 0);
7226       if (pa_number >= 0)
7227         {
7228           spnum = pa_number;
7229           input_line_pointer = ptemp;
7230         }
7231       else
7232         {
7233           while (!is_end_of_statement ())
7234             {
7235               input_line_pointer++;
7236               name = input_line_pointer;
7237               c = get_symbol_end ();
7238               if ((strncasecmp (name, "spnum", 5) == 0))
7239                 {
7240                   *input_line_pointer = c;
7241                   input_line_pointer++;
7242                   spnum = get_absolute_expression ();
7243                 }
7244               else if ((strncasecmp (name, "sort", 4) == 0))
7245                 {
7246                   *input_line_pointer = c;
7247                   input_line_pointer++;
7248                   sort = get_absolute_expression ();
7249                 }
7250               else if ((strncasecmp (name, "unloadable", 10) == 0))
7251                 {
7252                   *input_line_pointer = c;
7253                   loadable = FALSE;
7254                 }
7255               else if ((strncasecmp (name, "notdefined", 10) == 0))
7256                 {
7257                   *input_line_pointer = c;
7258                   defined = FALSE;
7259                 }
7260               else if ((strncasecmp (name, "private", 7) == 0))
7261                 {
7262                   *input_line_pointer = c;
7263                   private = TRUE;
7264                 }
7265               else
7266                 {
7267                   as_bad (_("Invalid .SPACE argument"));
7268                   *input_line_pointer = c;
7269                   if (!is_end_of_statement ())
7270                     input_line_pointer++;
7271                 }
7272             }
7273         }
7274       print_errors = TRUE;
7275     }
7276
7277   if (create_flag && seg == NULL)
7278     seg = subseg_new (space_name, 0);
7279
7280   /* If create_flag is nonzero, then create the new space with
7281      the attributes computed above.  Else set the values in
7282      an already existing space -- this can only happen for
7283      the first occurrence of a built-in space.  */
7284   if (create_flag)
7285     space = create_new_space (space_name, spnum, loadable, defined,
7286                               private, sort, seg, 1);
7287   else
7288     {
7289       space = is_defined_space (space_name);
7290       SPACE_SPNUM (space) = spnum;
7291       SPACE_DEFINED (space) = defined & 1;
7292       SPACE_USER_DEFINED (space) = 1;
7293     }
7294
7295 #ifdef obj_set_section_attributes
7296   obj_set_section_attributes (seg, defined, private, sort, spnum);
7297 #endif
7298
7299   return space;
7300 }
7301
7302 /* Handle a .SPACE pseudo-op; this switches the current space to the
7303    given space, creating the new space if necessary.  */
7304
7305 static void
7306 pa_space (unused)
7307      int unused ATTRIBUTE_UNUSED;
7308 {
7309   char *name, c, *space_name, *save_s;
7310   sd_chain_struct *sd_chain;
7311
7312   if (within_procedure)
7313     {
7314       as_bad (_("Can\'t change spaces within a procedure definition. Ignored"));
7315       ignore_rest_of_line ();
7316     }
7317   else
7318     {
7319       /* Check for some of the predefined spaces.   FIXME: most of the code
7320          below is repeated several times, can we extract the common parts
7321          and place them into a subroutine or something similar?  */
7322       /* FIXME Is this (and the next IF stmt) really right?
7323          What if INPUT_LINE_POINTER points to "$TEXT$FOO"?  */
7324       if (strncmp (input_line_pointer, "$TEXT$", 6) == 0)
7325         {
7326           input_line_pointer += 6;
7327           sd_chain = is_defined_space ("$TEXT$");
7328           if (sd_chain == NULL)
7329             sd_chain = pa_parse_space_stmt ("$TEXT$", 1);
7330           else if (SPACE_USER_DEFINED (sd_chain) == 0)
7331             sd_chain = pa_parse_space_stmt ("$TEXT$", 0);
7332
7333           current_space = sd_chain;
7334           subseg_set (text_section, sd_chain->sd_last_subseg);
7335           current_subspace
7336             = pa_subsegment_to_subspace (text_section,
7337                                          sd_chain->sd_last_subseg);
7338           demand_empty_rest_of_line ();
7339           return;
7340         }
7341       if (strncmp (input_line_pointer, "$PRIVATE$", 9) == 0)
7342         {
7343           input_line_pointer += 9;
7344           sd_chain = is_defined_space ("$PRIVATE$");
7345           if (sd_chain == NULL)
7346             sd_chain = pa_parse_space_stmt ("$PRIVATE$", 1);
7347           else if (SPACE_USER_DEFINED (sd_chain) == 0)
7348             sd_chain = pa_parse_space_stmt ("$PRIVATE$", 0);
7349
7350           current_space = sd_chain;
7351           subseg_set (data_section, sd_chain->sd_last_subseg);
7352           current_subspace
7353             = pa_subsegment_to_subspace (data_section,
7354                                          sd_chain->sd_last_subseg);
7355           demand_empty_rest_of_line ();
7356           return;
7357         }
7358       if (!strncasecmp (input_line_pointer,
7359                         GDB_DEBUG_SPACE_NAME,
7360                         strlen (GDB_DEBUG_SPACE_NAME)))
7361         {
7362           input_line_pointer += strlen (GDB_DEBUG_SPACE_NAME);
7363           sd_chain = is_defined_space (GDB_DEBUG_SPACE_NAME);
7364           if (sd_chain == NULL)
7365             sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 1);
7366           else if (SPACE_USER_DEFINED (sd_chain) == 0)
7367             sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 0);
7368
7369           current_space = sd_chain;
7370
7371           {
7372             asection *gdb_section
7373             = bfd_make_section_old_way (stdoutput, GDB_DEBUG_SPACE_NAME);
7374
7375             subseg_set (gdb_section, sd_chain->sd_last_subseg);
7376             current_subspace
7377               = pa_subsegment_to_subspace (gdb_section,
7378                                            sd_chain->sd_last_subseg);
7379           }
7380           demand_empty_rest_of_line ();
7381           return;
7382         }
7383
7384       /* It could be a space specified by number.  */
7385       print_errors = 0;
7386       save_s = input_line_pointer;
7387       strict = 0;
7388       pa_parse_number (&input_line_pointer, 0);
7389       if (pa_number >= 0)
7390         {
7391           if ((sd_chain = pa_find_space_by_number (pa_number)))
7392             {
7393               current_space = sd_chain;
7394
7395               subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
7396               current_subspace
7397                 = pa_subsegment_to_subspace (sd_chain->sd_seg,
7398                                              sd_chain->sd_last_subseg);
7399               demand_empty_rest_of_line ();
7400               return;
7401             }
7402         }
7403
7404       /* Not a number, attempt to create a new space.  */
7405       print_errors = 1;
7406       input_line_pointer = save_s;
7407       name = input_line_pointer;
7408       c = get_symbol_end ();
7409       space_name = xmalloc (strlen (name) + 1);
7410       strcpy (space_name, name);
7411       *input_line_pointer = c;
7412
7413       sd_chain = pa_parse_space_stmt (space_name, 1);
7414       current_space = sd_chain;
7415
7416       subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
7417       current_subspace = pa_subsegment_to_subspace (sd_chain->sd_seg,
7418                                                   sd_chain->sd_last_subseg);
7419       demand_empty_rest_of_line ();
7420     }
7421 }
7422
7423 /* Switch to a new space.  (I think).  FIXME.  */
7424
7425 static void
7426 pa_spnum (unused)
7427      int unused ATTRIBUTE_UNUSED;
7428 {
7429   char *name;
7430   char c;
7431   char *p;
7432   sd_chain_struct *space;
7433
7434   name = input_line_pointer;
7435   c = get_symbol_end ();
7436   space = is_defined_space (name);
7437   if (space)
7438     {
7439       p = frag_more (4);
7440       md_number_to_chars (p, SPACE_SPNUM (space), 4);
7441     }
7442   else
7443     as_warn (_("Undefined space: '%s' Assuming space number = 0."), name);
7444
7445   *input_line_pointer = c;
7446   demand_empty_rest_of_line ();
7447 }
7448
7449 /* Handle a .SUBSPACE pseudo-op; this switches the current subspace to the
7450    given subspace, creating the new subspace if necessary.
7451
7452    FIXME.  Should mirror pa_space more closely, in particular how
7453    they're broken up into subroutines.  */
7454
7455 static void
7456 pa_subspace (create_new)
7457      int create_new;
7458 {
7459   char *name, *ss_name, c;
7460   char loadable, code_only, comdat, common, dup_common, zero, sort;
7461   int i, access, space_index, alignment, quadrant, applicable, flags;
7462   sd_chain_struct *space;
7463   ssd_chain_struct *ssd;
7464   asection *section;
7465
7466   if (current_space == NULL)
7467     as_fatal (_("Must be in a space before changing or declaring subspaces.\n"));
7468
7469   if (within_procedure)
7470     {
7471       as_bad (_("Can\'t change subspaces within a procedure definition. Ignored"));
7472       ignore_rest_of_line ();
7473     }
7474   else
7475     {
7476       name = input_line_pointer;
7477       c = get_symbol_end ();
7478       ss_name = xmalloc (strlen (name) + 1);
7479       strcpy (ss_name, name);
7480       *input_line_pointer = c;
7481
7482       /* Load default values.  */
7483       sort = 0;
7484       access = 0x7f;
7485       loadable = 1;
7486       comdat = 0;
7487       common = 0;
7488       dup_common = 0;
7489       code_only = 0;
7490       zero = 0;
7491       space_index = ~0;
7492       alignment = 1;
7493       quadrant = 0;
7494
7495       space = current_space;
7496       if (create_new)
7497         ssd = NULL;
7498       else
7499         ssd = is_defined_subspace (ss_name);
7500       /* Allow user to override the builtin attributes of subspaces.  But
7501          only allow the attributes to be changed once!  */
7502       if (ssd && SUBSPACE_DEFINED (ssd))
7503         {
7504           subseg_set (ssd->ssd_seg, ssd->ssd_subseg);
7505           current_subspace = ssd;
7506           if (!is_end_of_statement ())
7507             as_warn (_("Parameters of an existing subspace can\'t be modified"));
7508           demand_empty_rest_of_line ();
7509           return;
7510         }
7511       else
7512         {
7513           /* A new subspace.  Load default values if it matches one of
7514              the builtin subspaces.  */
7515           i = 0;
7516           while (pa_def_subspaces[i].name)
7517             {
7518               if (strcasecmp (pa_def_subspaces[i].name, ss_name) == 0)
7519                 {
7520                   loadable = pa_def_subspaces[i].loadable;
7521                   comdat = pa_def_subspaces[i].comdat;
7522                   common = pa_def_subspaces[i].common;
7523                   dup_common = pa_def_subspaces[i].dup_common;
7524                   code_only = pa_def_subspaces[i].code_only;
7525                   zero = pa_def_subspaces[i].zero;
7526                   space_index = pa_def_subspaces[i].space_index;
7527                   alignment = pa_def_subspaces[i].alignment;
7528                   quadrant = pa_def_subspaces[i].quadrant;
7529                   access = pa_def_subspaces[i].access;
7530                   sort = pa_def_subspaces[i].sort;
7531                   break;
7532                 }
7533               i++;
7534             }
7535         }
7536
7537       /* We should be working with a new subspace now.  Fill in
7538          any information as specified by the user.  */
7539       if (!is_end_of_statement ())
7540         {
7541           input_line_pointer++;
7542           while (!is_end_of_statement ())
7543             {
7544               name = input_line_pointer;
7545               c = get_symbol_end ();
7546               if ((strncasecmp (name, "quad", 4) == 0))
7547                 {
7548                   *input_line_pointer = c;
7549                   input_line_pointer++;
7550                   quadrant = get_absolute_expression ();
7551                 }
7552               else if ((strncasecmp (name, "align", 5) == 0))
7553                 {
7554                   *input_line_pointer = c;
7555                   input_line_pointer++;
7556                   alignment = get_absolute_expression ();
7557                   if (exact_log2 (alignment) == -1)
7558                     {
7559                       as_bad (_("Alignment must be a power of 2"));
7560                       alignment = 1;
7561                     }
7562                 }
7563               else if ((strncasecmp (name, "access", 6) == 0))
7564                 {
7565                   *input_line_pointer = c;
7566                   input_line_pointer++;
7567                   access = get_absolute_expression ();
7568                 }
7569               else if ((strncasecmp (name, "sort", 4) == 0))
7570                 {
7571                   *input_line_pointer = c;
7572                   input_line_pointer++;
7573                   sort = get_absolute_expression ();
7574                 }
7575               else if ((strncasecmp (name, "code_only", 9) == 0))
7576                 {
7577                   *input_line_pointer = c;
7578                   code_only = 1;
7579                 }
7580               else if ((strncasecmp (name, "unloadable", 10) == 0))
7581                 {
7582                   *input_line_pointer = c;
7583                   loadable = 0;
7584                 }
7585               else if ((strncasecmp (name, "comdat", 6) == 0))
7586                 {
7587                   *input_line_pointer = c;
7588                   comdat = 1;
7589                 }
7590               else if ((strncasecmp (name, "common", 6) == 0))
7591                 {
7592                   *input_line_pointer = c;
7593                   common = 1;
7594                 }
7595               else if ((strncasecmp (name, "dup_comm", 8) == 0))
7596                 {
7597                   *input_line_pointer = c;
7598                   dup_common = 1;
7599                 }
7600               else if ((strncasecmp (name, "zero", 4) == 0))
7601                 {
7602                   *input_line_pointer = c;
7603                   zero = 1;
7604                 }
7605               else if ((strncasecmp (name, "first", 5) == 0))
7606                 as_bad (_("FIRST not supported as a .SUBSPACE argument"));
7607               else
7608                 as_bad (_("Invalid .SUBSPACE argument"));
7609               if (!is_end_of_statement ())
7610                 input_line_pointer++;
7611             }
7612         }
7613
7614       /* Compute a reasonable set of BFD flags based on the information
7615          in the .subspace directive.  */
7616       applicable = bfd_applicable_section_flags (stdoutput);
7617       flags = 0;
7618       if (loadable)
7619         flags |= (SEC_ALLOC | SEC_LOAD);
7620       if (code_only)
7621         flags |= SEC_CODE;
7622
7623       /* These flags are used to implement various flavors of initialized
7624          common.  The SOM linker discards duplicate subspaces when they
7625          have the same "key" symbol name.  This support is more like
7626          GNU linkonce than BFD common.  Further, pc-relative relocations
7627          are converted to section relative relocations in BFD common
7628          sections.  This complicates the handling of relocations in
7629          common sections containing text and isn't currently supported
7630          correctly in the SOM BFD backend.  */
7631       if (comdat || common || dup_common)
7632         flags |= SEC_LINK_ONCE;
7633
7634       flags |= SEC_RELOC | SEC_HAS_CONTENTS;
7635
7636       /* This is a zero-filled subspace (eg BSS).  */
7637       if (zero)
7638         flags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
7639
7640       applicable &= flags;
7641
7642       /* If this is an existing subspace, then we want to use the
7643          segment already associated with the subspace.
7644
7645          FIXME NOW!  ELF BFD doesn't appear to be ready to deal with
7646          lots of sections.  It might be a problem in the PA ELF
7647          code, I do not know yet.  For now avoid creating anything
7648          but the "standard" sections for ELF.  */
7649       if (create_new)
7650         section = subseg_force_new (ss_name, 0);
7651       else if (ssd)
7652         section = ssd->ssd_seg;
7653       else
7654         section = subseg_new (ss_name, 0);
7655
7656       if (zero)
7657         seg_info (section)->bss = 1;
7658
7659       /* Now set the flags.  */
7660       bfd_set_section_flags (stdoutput, section, applicable);
7661
7662       /* Record any alignment request for this section.  */
7663       record_alignment (section, exact_log2 (alignment));
7664
7665       /* Set the starting offset for this section.  */
7666       bfd_set_section_vma (stdoutput, section,
7667                            pa_subspace_start (space, quadrant));
7668
7669       /* Now that all the flags are set, update an existing subspace,
7670          or create a new one.  */
7671       if (ssd)
7672
7673         current_subspace = update_subspace (space, ss_name, loadable,
7674                                             code_only, comdat, common,
7675                                             dup_common, sort, zero, access,
7676                                             space_index, alignment, quadrant,
7677                                             section);
7678       else
7679         current_subspace = create_new_subspace (space, ss_name, loadable,
7680                                                 code_only, comdat, common,
7681                                                 dup_common, zero, sort,
7682                                                 access, space_index,
7683                                                 alignment, quadrant, section);
7684
7685       demand_empty_rest_of_line ();
7686       current_subspace->ssd_seg = section;
7687       subseg_set (current_subspace->ssd_seg, current_subspace->ssd_subseg);
7688     }
7689   SUBSPACE_DEFINED (current_subspace) = 1;
7690 }
7691
7692 /* Create default space and subspace dictionaries.  */
7693
7694 static void
7695 pa_spaces_begin ()
7696 {
7697   int i;
7698
7699   space_dict_root = NULL;
7700   space_dict_last = NULL;
7701
7702   i = 0;
7703   while (pa_def_spaces[i].name)
7704     {
7705       char *name;
7706
7707       /* Pick the right name to use for the new section.  */
7708       name = pa_def_spaces[i].name;
7709
7710       pa_def_spaces[i].segment = subseg_new (name, 0);
7711       create_new_space (pa_def_spaces[i].name, pa_def_spaces[i].spnum,
7712                         pa_def_spaces[i].loadable, pa_def_spaces[i].defined,
7713                         pa_def_spaces[i].private, pa_def_spaces[i].sort,
7714                         pa_def_spaces[i].segment, 0);
7715       i++;
7716     }
7717
7718   i = 0;
7719   while (pa_def_subspaces[i].name)
7720     {
7721       char *name;
7722       int applicable, subsegment;
7723       asection *segment = NULL;
7724       sd_chain_struct *space;
7725
7726       /* Pick the right name for the new section and pick the right
7727          subsegment number.  */
7728       name = pa_def_subspaces[i].name;
7729       subsegment = 0;
7730
7731       /* Create the new section.  */
7732       segment = subseg_new (name, subsegment);
7733
7734       /* For SOM we want to replace the standard .text, .data, and .bss
7735          sections with our own.   We also want to set BFD flags for
7736          all the built-in subspaces.  */
7737       if (!strcmp (pa_def_subspaces[i].name, "$CODE$"))
7738         {
7739           text_section = segment;
7740           applicable = bfd_applicable_section_flags (stdoutput);
7741           bfd_set_section_flags (stdoutput, segment,
7742                                  applicable & (SEC_ALLOC | SEC_LOAD
7743                                                | SEC_RELOC | SEC_CODE
7744                                                | SEC_READONLY
7745                                                | SEC_HAS_CONTENTS));
7746         }
7747       else if (!strcmp (pa_def_subspaces[i].name, "$DATA$"))
7748         {
7749           data_section = segment;
7750           applicable = bfd_applicable_section_flags (stdoutput);
7751           bfd_set_section_flags (stdoutput, segment,
7752                                  applicable & (SEC_ALLOC | SEC_LOAD
7753                                                | SEC_RELOC
7754                                                | SEC_HAS_CONTENTS));
7755
7756         }
7757       else if (!strcmp (pa_def_subspaces[i].name, "$BSS$"))
7758         {
7759           bss_section = segment;
7760           applicable = bfd_applicable_section_flags (stdoutput);
7761           bfd_set_section_flags (stdoutput, segment,
7762                                  applicable & SEC_ALLOC);
7763         }
7764       else if (!strcmp (pa_def_subspaces[i].name, "$LIT$"))
7765         {
7766           applicable = bfd_applicable_section_flags (stdoutput);
7767           bfd_set_section_flags (stdoutput, segment,
7768                                  applicable & (SEC_ALLOC | SEC_LOAD
7769                                                | SEC_RELOC
7770                                                | SEC_READONLY
7771                                                | SEC_HAS_CONTENTS));
7772         }
7773       else if (!strcmp (pa_def_subspaces[i].name, "$MILLICODE$"))
7774         {
7775           applicable = bfd_applicable_section_flags (stdoutput);
7776           bfd_set_section_flags (stdoutput, segment,
7777                                  applicable & (SEC_ALLOC | SEC_LOAD
7778                                                | SEC_RELOC
7779                                                | SEC_READONLY
7780                                                | SEC_HAS_CONTENTS));
7781         }
7782       else if (!strcmp (pa_def_subspaces[i].name, "$UNWIND$"))
7783         {
7784           applicable = bfd_applicable_section_flags (stdoutput);
7785           bfd_set_section_flags (stdoutput, segment,
7786                                  applicable & (SEC_ALLOC | SEC_LOAD
7787                                                | SEC_RELOC
7788                                                | SEC_READONLY
7789                                                | SEC_HAS_CONTENTS));
7790         }
7791
7792       /* Find the space associated with this subspace.  */
7793       space = pa_segment_to_space (pa_def_spaces[pa_def_subspaces[i].
7794                                                  def_space_index].segment);
7795       if (space == NULL)
7796         {
7797           as_fatal (_("Internal error: Unable to find containing space for %s."),
7798                     pa_def_subspaces[i].name);
7799         }
7800
7801       create_new_subspace (space, name,
7802                            pa_def_subspaces[i].loadable,
7803                            pa_def_subspaces[i].code_only,
7804                            pa_def_subspaces[i].comdat,
7805                            pa_def_subspaces[i].common,
7806                            pa_def_subspaces[i].dup_common,
7807                            pa_def_subspaces[i].zero,
7808                            pa_def_subspaces[i].sort,
7809                            pa_def_subspaces[i].access,
7810                            pa_def_subspaces[i].space_index,
7811                            pa_def_subspaces[i].alignment,
7812                            pa_def_subspaces[i].quadrant,
7813                            segment);
7814       i++;
7815     }
7816 }
7817
7818 /* Create a new space NAME, with the appropriate flags as defined
7819    by the given parameters.  */
7820
7821 static sd_chain_struct *
7822 create_new_space (name, spnum, loadable, defined, private,
7823                   sort, seg, user_defined)
7824      char *name;
7825      int spnum;
7826      int loadable ATTRIBUTE_UNUSED;
7827      int defined;
7828      int private;
7829      int sort;
7830      asection *seg;
7831      int user_defined;
7832 {
7833   sd_chain_struct *chain_entry;
7834
7835   chain_entry = (sd_chain_struct *) xmalloc (sizeof (sd_chain_struct));
7836   if (!chain_entry)
7837     as_fatal (_("Out of memory: could not allocate new space chain entry: %s\n"),
7838               name);
7839
7840   SPACE_NAME (chain_entry) = (char *) xmalloc (strlen (name) + 1);
7841   strcpy (SPACE_NAME (chain_entry), name);
7842   SPACE_DEFINED (chain_entry) = defined;
7843   SPACE_USER_DEFINED (chain_entry) = user_defined;
7844   SPACE_SPNUM (chain_entry) = spnum;
7845
7846   chain_entry->sd_seg = seg;
7847   chain_entry->sd_last_subseg = -1;
7848   chain_entry->sd_subspaces = NULL;
7849   chain_entry->sd_next = NULL;
7850
7851   /* Find spot for the new space based on its sort key.  */
7852   if (!space_dict_last)
7853     space_dict_last = chain_entry;
7854
7855   if (space_dict_root == NULL)
7856     space_dict_root = chain_entry;
7857   else
7858     {
7859       sd_chain_struct *chain_pointer;
7860       sd_chain_struct *prev_chain_pointer;
7861
7862       chain_pointer = space_dict_root;
7863       prev_chain_pointer = NULL;
7864
7865       while (chain_pointer)
7866         {
7867           prev_chain_pointer = chain_pointer;
7868           chain_pointer = chain_pointer->sd_next;
7869         }
7870
7871       /* At this point we've found the correct place to add the new
7872          entry.  So add it and update the linked lists as appropriate.  */
7873       if (prev_chain_pointer)
7874         {
7875           chain_entry->sd_next = chain_pointer;
7876           prev_chain_pointer->sd_next = chain_entry;
7877         }
7878       else
7879         {
7880           space_dict_root = chain_entry;
7881           chain_entry->sd_next = chain_pointer;
7882         }
7883
7884       if (chain_entry->sd_next == NULL)
7885         space_dict_last = chain_entry;
7886     }
7887
7888   /* This is here to catch predefined spaces which do not get
7889      modified by the user's input.  Another call is found at
7890      the bottom of pa_parse_space_stmt to handle cases where
7891      the user modifies a predefined space.  */
7892 #ifdef obj_set_section_attributes
7893   obj_set_section_attributes (seg, defined, private, sort, spnum);
7894 #endif
7895
7896   return chain_entry;
7897 }
7898
7899 /* Create a new subspace NAME, with the appropriate flags as defined
7900    by the given parameters.
7901
7902    Add the new subspace to the subspace dictionary chain in numerical
7903    order as defined by the SORT entries.  */
7904
7905 static ssd_chain_struct *
7906 create_new_subspace (space, name, loadable, code_only, comdat, common,
7907                      dup_common, is_zero, sort, access, space_index,
7908                      alignment, quadrant, seg)
7909      sd_chain_struct *space;
7910      char *name;
7911      int loadable ATTRIBUTE_UNUSED;
7912      int code_only ATTRIBUTE_UNUSED;
7913      int comdat, common, dup_common;
7914      int is_zero ATTRIBUTE_UNUSED;
7915      int sort;
7916      int access;
7917      int space_index ATTRIBUTE_UNUSED;
7918      int alignment ATTRIBUTE_UNUSED;
7919      int quadrant;
7920      asection *seg;
7921 {
7922   ssd_chain_struct *chain_entry;
7923
7924   chain_entry = (ssd_chain_struct *) xmalloc (sizeof (ssd_chain_struct));
7925   if (!chain_entry)
7926     as_fatal (_("Out of memory: could not allocate new subspace chain entry: %s\n"), name);
7927
7928   SUBSPACE_NAME (chain_entry) = (char *) xmalloc (strlen (name) + 1);
7929   strcpy (SUBSPACE_NAME (chain_entry), name);
7930
7931   /* Initialize subspace_defined.  When we hit a .subspace directive
7932      we'll set it to 1 which "locks-in" the subspace attributes.  */
7933   SUBSPACE_DEFINED (chain_entry) = 0;
7934
7935   chain_entry->ssd_subseg = 0;
7936   chain_entry->ssd_seg = seg;
7937   chain_entry->ssd_next = NULL;
7938
7939   /* Find spot for the new subspace based on its sort key.  */
7940   if (space->sd_subspaces == NULL)
7941     space->sd_subspaces = chain_entry;
7942   else
7943     {
7944       ssd_chain_struct *chain_pointer;
7945       ssd_chain_struct *prev_chain_pointer;
7946
7947       chain_pointer = space->sd_subspaces;
7948       prev_chain_pointer = NULL;
7949
7950       while (chain_pointer)
7951         {
7952           prev_chain_pointer = chain_pointer;
7953           chain_pointer = chain_pointer->ssd_next;
7954         }
7955
7956       /* Now we have somewhere to put the new entry.  Insert it and update
7957          the links.  */
7958       if (prev_chain_pointer)
7959         {
7960           chain_entry->ssd_next = chain_pointer;
7961           prev_chain_pointer->ssd_next = chain_entry;
7962         }
7963       else
7964         {
7965           space->sd_subspaces = chain_entry;
7966           chain_entry->ssd_next = chain_pointer;
7967         }
7968     }
7969
7970 #ifdef obj_set_subsection_attributes
7971   obj_set_subsection_attributes (seg, space->sd_seg, access, sort,
7972                                  quadrant, comdat, common, dup_common);
7973 #endif
7974
7975   return chain_entry;
7976 }
7977
7978 /* Update the information for the given subspace based upon the
7979    various arguments.   Return the modified subspace chain entry.  */
7980
7981 static ssd_chain_struct *
7982 update_subspace (space, name, loadable, code_only, comdat, common, dup_common,
7983                  sort, zero, access, space_index, alignment, quadrant, section)
7984      sd_chain_struct *space;
7985      char *name;
7986      int loadable ATTRIBUTE_UNUSED;
7987      int code_only ATTRIBUTE_UNUSED;
7988      int comdat;
7989      int common;
7990      int dup_common;
7991      int zero ATTRIBUTE_UNUSED;
7992      int sort;
7993      int access;
7994      int space_index ATTRIBUTE_UNUSED;
7995      int alignment ATTRIBUTE_UNUSED;
7996      int quadrant;
7997      asection *section;
7998 {
7999   ssd_chain_struct *chain_entry;
8000
8001   chain_entry = is_defined_subspace (name);
8002
8003 #ifdef obj_set_subsection_attributes
8004   obj_set_subsection_attributes (section, space->sd_seg, access, sort,
8005                                  quadrant, comdat, common, dup_common);
8006 #endif
8007
8008   return chain_entry;
8009 }
8010
8011 /* Return the space chain entry for the space with the name NAME or
8012    NULL if no such space exists.  */
8013
8014 static sd_chain_struct *
8015 is_defined_space (name)
8016      char *name;
8017 {
8018   sd_chain_struct *chain_pointer;
8019
8020   for (chain_pointer = space_dict_root;
8021        chain_pointer;
8022        chain_pointer = chain_pointer->sd_next)
8023     {
8024       if (strcmp (SPACE_NAME (chain_pointer), name) == 0)
8025         return chain_pointer;
8026     }
8027
8028   /* No mapping from segment to space was found.  Return NULL.  */
8029   return NULL;
8030 }
8031
8032 /* Find and return the space associated with the given seg.  If no mapping
8033    from the given seg to a space is found, then return NULL.
8034
8035    Unlike subspaces, the number of spaces is not expected to grow much,
8036    so a linear exhaustive search is OK here.  */
8037
8038 static sd_chain_struct *
8039 pa_segment_to_space (seg)
8040      asection *seg;
8041 {
8042   sd_chain_struct *space_chain;
8043
8044   /* Walk through each space looking for the correct mapping.  */
8045   for (space_chain = space_dict_root;
8046        space_chain;
8047        space_chain = space_chain->sd_next)
8048     {
8049       if (space_chain->sd_seg == seg)
8050         return space_chain;
8051     }
8052
8053   /* Mapping was not found.  Return NULL.  */
8054   return NULL;
8055 }
8056
8057 /* Return the first space chain entry for the subspace with the name
8058    NAME or NULL if no such subspace exists.
8059
8060    When there are multiple subspaces with the same name, switching to
8061    the first (i.e., default) subspace is preferable in most situations.
8062    For example, it wouldn't be desirable to merge COMDAT data with non
8063    COMDAT data.
8064
8065    Uses a linear search through all the spaces and subspaces, this may
8066    not be appropriate if we ever being placing each function in its
8067    own subspace.  */
8068
8069 static ssd_chain_struct *
8070 is_defined_subspace (name)
8071      char *name;
8072 {
8073   sd_chain_struct *space_chain;
8074   ssd_chain_struct *subspace_chain;
8075
8076   /* Walk through each space.  */
8077   for (space_chain = space_dict_root;
8078        space_chain;
8079        space_chain = space_chain->sd_next)
8080     {
8081       /* Walk through each subspace looking for a name which matches.  */
8082       for (subspace_chain = space_chain->sd_subspaces;
8083            subspace_chain;
8084            subspace_chain = subspace_chain->ssd_next)
8085         if (strcmp (SUBSPACE_NAME (subspace_chain), name) == 0)
8086           return subspace_chain;
8087     }
8088
8089   /* Subspace wasn't found.  Return NULL.  */
8090   return NULL;
8091 }
8092
8093 /* Find and return the subspace associated with the given seg.  If no
8094    mapping from the given seg to a subspace is found, then return NULL.
8095
8096    If we ever put each procedure/function within its own subspace
8097    (to make life easier on the compiler and linker), then this will have
8098    to become more efficient.  */
8099
8100 static ssd_chain_struct *
8101 pa_subsegment_to_subspace (seg, subseg)
8102      asection *seg;
8103      subsegT subseg;
8104 {
8105   sd_chain_struct *space_chain;
8106   ssd_chain_struct *subspace_chain;
8107
8108   /* Walk through each space.  */
8109   for (space_chain = space_dict_root;
8110        space_chain;
8111        space_chain = space_chain->sd_next)
8112     {
8113       if (space_chain->sd_seg == seg)
8114         {
8115           /* Walk through each subspace within each space looking for
8116              the correct mapping.  */
8117           for (subspace_chain = space_chain->sd_subspaces;
8118                subspace_chain;
8119                subspace_chain = subspace_chain->ssd_next)
8120             if (subspace_chain->ssd_subseg == (int) subseg)
8121               return subspace_chain;
8122         }
8123     }
8124
8125   /* No mapping from subsegment to subspace found.  Return NULL.  */
8126   return NULL;
8127 }
8128
8129 /* Given a number, try and find a space with the name number.
8130
8131    Return a pointer to a space dictionary chain entry for the space
8132    that was found or NULL on failure.  */
8133
8134 static sd_chain_struct *
8135 pa_find_space_by_number (number)
8136      int number;
8137 {
8138   sd_chain_struct *space_chain;
8139
8140   for (space_chain = space_dict_root;
8141        space_chain;
8142        space_chain = space_chain->sd_next)
8143     {
8144       if (SPACE_SPNUM (space_chain) == (unsigned int) number)
8145         return space_chain;
8146     }
8147
8148   /* No appropriate space found.  Return NULL.  */
8149   return NULL;
8150 }
8151
8152 /* Return the starting address for the given subspace.  If the starting
8153    address is unknown then return zero.  */
8154
8155 static unsigned int
8156 pa_subspace_start (space, quadrant)
8157      sd_chain_struct *space;
8158      int quadrant;
8159 {
8160   /* FIXME.  Assumes everyone puts read/write data at 0x4000000, this
8161      is not correct for the PA OSF1 port.  */
8162   if ((strcmp (SPACE_NAME (space), "$PRIVATE$") == 0) && quadrant == 1)
8163     return 0x40000000;
8164   else if (space->sd_seg == data_section && quadrant == 1)
8165     return 0x40000000;
8166   else
8167     return 0;
8168   return 0;
8169 }
8170 #endif
8171
8172 /* Helper function for pa_stringer.  Used to find the end of
8173    a string.  */
8174
8175 static unsigned int
8176 pa_stringer_aux (s)
8177      char *s;
8178 {
8179   unsigned int c = *s & CHAR_MASK;
8180
8181   switch (c)
8182     {
8183     case '\"':
8184       c = NOT_A_CHAR;
8185       break;
8186     default:
8187       break;
8188     }
8189   return c;
8190 }
8191
8192 /* Handle a .STRING type pseudo-op.  */
8193
8194 static void
8195 pa_stringer (append_zero)
8196      int append_zero;
8197 {
8198   char *s, num_buf[4];
8199   unsigned int c;
8200   int i;
8201
8202   /* Preprocess the string to handle PA-specific escape sequences.
8203      For example, \xDD where DD is a hexadecimal number should be
8204      changed to \OOO where OOO is an octal number.  */
8205
8206 #ifdef OBJ_SOM
8207   /* We must have a valid space and subspace.  */
8208   pa_check_current_space_and_subspace ();
8209 #endif
8210
8211   /* Skip the opening quote.  */
8212   s = input_line_pointer + 1;
8213
8214   while (is_a_char (c = pa_stringer_aux (s++)))
8215     {
8216       if (c == '\\')
8217         {
8218           c = *s;
8219           switch (c)
8220             {
8221               /* Handle \x<num>.  */
8222             case 'x':
8223               {
8224                 unsigned int number;
8225                 int num_digit;
8226                 char dg;
8227                 char *s_start = s;
8228
8229                 /* Get past the 'x'.  */
8230                 s++;
8231                 for (num_digit = 0, number = 0, dg = *s;
8232                      num_digit < 2
8233                      && (ISDIGIT (dg) || (dg >= 'a' && dg <= 'f')
8234                          || (dg >= 'A' && dg <= 'F'));
8235                      num_digit++)
8236                   {
8237                     if (ISDIGIT (dg))
8238                       number = number * 16 + dg - '0';
8239                     else if (dg >= 'a' && dg <= 'f')
8240                       number = number * 16 + dg - 'a' + 10;
8241                     else
8242                       number = number * 16 + dg - 'A' + 10;
8243
8244                     s++;
8245                     dg = *s;
8246                   }
8247                 if (num_digit > 0)
8248                   {
8249                     switch (num_digit)
8250                       {
8251                       case 1:
8252                         sprintf (num_buf, "%02o", number);
8253                         break;
8254                       case 2:
8255                         sprintf (num_buf, "%03o", number);
8256                         break;
8257                       }
8258                     for (i = 0; i <= num_digit; i++)
8259                       s_start[i] = num_buf[i];
8260                   }
8261                 break;
8262               }
8263             /* This might be a "\"", skip over the escaped char.  */
8264             default:
8265               s++;
8266               break;
8267             }
8268         }
8269     }
8270   stringer (append_zero);
8271   pa_undefine_label ();
8272 }
8273
8274 /* Handle a .VERSION pseudo-op.  */
8275
8276 static void
8277 pa_version (unused)
8278      int unused ATTRIBUTE_UNUSED;
8279 {
8280   obj_version (0);
8281   pa_undefine_label ();
8282 }
8283
8284 #ifdef OBJ_SOM
8285
8286 /* Handle a .COMPILER pseudo-op.  */
8287
8288 static void
8289 pa_compiler (unused)
8290      int unused ATTRIBUTE_UNUSED;
8291 {
8292   obj_som_compiler (0);
8293   pa_undefine_label ();
8294 }
8295
8296 #endif
8297
8298 /* Handle a .COPYRIGHT pseudo-op.  */
8299
8300 static void
8301 pa_copyright (unused)
8302      int unused ATTRIBUTE_UNUSED;
8303 {
8304   obj_copyright (0);
8305   pa_undefine_label ();
8306 }
8307
8308 /* Just like a normal cons, but when finished we have to undefine
8309    the latest space label.  */
8310
8311 static void
8312 pa_cons (nbytes)
8313      int nbytes;
8314 {
8315   cons (nbytes);
8316   pa_undefine_label ();
8317 }
8318
8319 /* Like float_cons, but we need to undefine our label.  */
8320
8321 static void
8322 pa_float_cons (float_type)
8323      int float_type;
8324 {
8325   float_cons (float_type);
8326   pa_undefine_label ();
8327 }
8328
8329 /* Like s_fill, but delete our label when finished.  */
8330
8331 static void
8332 pa_fill (unused)
8333      int unused ATTRIBUTE_UNUSED;
8334 {
8335 #ifdef OBJ_SOM
8336   /* We must have a valid space and subspace.  */
8337   pa_check_current_space_and_subspace ();
8338 #endif
8339
8340   s_fill (0);
8341   pa_undefine_label ();
8342 }
8343
8344 /* Like lcomm, but delete our label when finished.  */
8345
8346 static void
8347 pa_lcomm (needs_align)
8348      int needs_align;
8349 {
8350 #ifdef OBJ_SOM
8351   /* We must have a valid space and subspace.  */
8352   pa_check_current_space_and_subspace ();
8353 #endif
8354
8355   s_lcomm (needs_align);
8356   pa_undefine_label ();
8357 }
8358
8359 /* Like lsym, but delete our label when finished.  */
8360
8361 static void
8362 pa_lsym (unused)
8363      int unused ATTRIBUTE_UNUSED;
8364 {
8365 #ifdef OBJ_SOM
8366   /* We must have a valid space and subspace.  */
8367   pa_check_current_space_and_subspace ();
8368 #endif
8369
8370   s_lsym (0);
8371   pa_undefine_label ();
8372 }
8373
8374 /* On the PA relocations which involve function symbols must not be
8375    adjusted.  This so that the linker can know when/how to create argument
8376    relocation stubs for indirect calls and calls to static functions.
8377
8378    "T" field selectors create DLT relative fixups for accessing
8379    globals and statics in PIC code; each DLT relative fixup creates
8380    an entry in the DLT table.  The entries contain the address of
8381    the final target (eg accessing "foo" would create a DLT entry
8382    with the address of "foo").
8383
8384    Unfortunately, the HP linker doesn't take into account any addend
8385    when generating the DLT; so accessing $LIT$+8 puts the address of
8386    $LIT$ into the DLT rather than the address of $LIT$+8.
8387
8388    The end result is we can't perform relocation symbol reductions for
8389    any fixup which creates entries in the DLT (eg they use "T" field
8390    selectors).
8391
8392    Reject reductions involving symbols with external scope; such
8393    reductions make life a living hell for object file editors.
8394
8395    FIXME.  Also reject R_HPPA relocations which are 32bits wide in
8396    the code space.  The SOM BFD backend doesn't know how to pull the
8397    right bits out of an instruction.  */
8398
8399 int
8400 hppa_fix_adjustable (fixp)
8401      fixS *fixp;
8402 {
8403 #ifdef OBJ_ELF
8404   reloc_type code;
8405 #endif
8406   struct hppa_fix_struct *hppa_fix;
8407
8408   hppa_fix = (struct hppa_fix_struct *) fixp->tc_fix_data;
8409
8410 #ifdef OBJ_SOM
8411   /* Reject reductions of symbols in 32bit relocs unless they
8412      are fake labels.  */
8413   if (fixp->fx_r_type == R_HPPA
8414       && hppa_fix->fx_r_format == 32
8415       && strncmp (S_GET_NAME (fixp->fx_addsy),
8416                   FAKE_LABEL_NAME,
8417                   strlen (FAKE_LABEL_NAME)))
8418     return 0;
8419 #endif
8420
8421 #ifdef OBJ_ELF
8422   /* LR/RR selectors are implicitly used for a number of different relocation
8423      types.  We must ensure that none of these types are adjusted (see below)
8424      even if they occur with a different selector.  */
8425   code = elf_hppa_reloc_final_type (stdoutput, fixp->fx_r_type,
8426                                     hppa_fix->fx_r_format,
8427                                     hppa_fix->fx_r_field);
8428
8429   switch (code)
8430     {
8431     /* Relocation types which use e_lrsel.  */
8432     case R_PARISC_DIR21L:
8433     case R_PARISC_DLTREL21L:
8434     case R_PARISC_DPREL21L:
8435     case R_PARISC_PLTOFF21L:
8436
8437     /* Relocation types which use e_rrsel.  */
8438     case R_PARISC_DIR14R:
8439     case R_PARISC_DIR14DR:
8440     case R_PARISC_DIR14WR:
8441     case R_PARISC_DIR17R:
8442     case R_PARISC_DLTREL14R:
8443     case R_PARISC_DLTREL14DR:
8444     case R_PARISC_DLTREL14WR:
8445     case R_PARISC_DPREL14R:
8446     case R_PARISC_DPREL14DR:
8447     case R_PARISC_DPREL14WR:
8448     case R_PARISC_PLTOFF14R:
8449     case R_PARISC_PLTOFF14DR:
8450     case R_PARISC_PLTOFF14WR:
8451
8452     /* Other types that we reject for reduction.  */
8453     case R_PARISC_GNU_VTENTRY:
8454     case R_PARISC_GNU_VTINHERIT:
8455       return 0;
8456     default:
8457       break;
8458     }
8459 #endif
8460
8461   /* Reject reductions of symbols in sym1-sym2 expressions when
8462      the fixup will occur in a CODE subspace.
8463
8464      XXX FIXME: Long term we probably want to reject all of these;
8465      for example reducing in the debug section would lose if we ever
8466      supported using the optimizing hp linker.  */
8467   if (fixp->fx_addsy
8468       && fixp->fx_subsy
8469       && (hppa_fix->segment->flags & SEC_CODE))
8470     return 0;
8471
8472   /* We can't adjust any relocs that use LR% and RR% field selectors.
8473
8474      If a symbol is reduced to a section symbol, the assembler will
8475      adjust the addend unless the symbol happens to reside right at
8476      the start of the section.  Additionally, the linker has no choice
8477      but to manipulate the addends when coalescing input sections for
8478      "ld -r".  Since an LR% field selector is defined to round the
8479      addend, we can't change the addend without risking that a LR% and
8480      it's corresponding (possible multiple) RR% field will no longer
8481      sum to the right value.
8482
8483      eg. Suppose we have
8484      .          ldil    LR%foo+0,%r21
8485      .          ldw     RR%foo+0(%r21),%r26
8486      .          ldw     RR%foo+4(%r21),%r25
8487
8488      If foo is at address 4092 (decimal) in section `sect', then after
8489      reducing to the section symbol we get
8490      .                  LR%sect+4092 == (L%sect)+0
8491      .                  RR%sect+4092 == (R%sect)+4092
8492      .                  RR%sect+4096 == (R%sect)-4096
8493      and the last address loses because rounding the addend to 8k
8494      multiples takes us up to 8192 with an offset of -4096.
8495
8496      In cases where the LR% expression is identical to the RR% one we
8497      will never have a problem, but is so happens that gcc rounds
8498      addends involved in LR% field selectors to work around a HP
8499      linker bug.  ie. We often have addresses like the last case
8500      above where the LR% expression is offset from the RR% one.  */
8501
8502   if (hppa_fix->fx_r_field == e_lrsel
8503       || hppa_fix->fx_r_field == e_rrsel
8504       || hppa_fix->fx_r_field == e_nlrsel)
8505     return 0;
8506
8507   /* Reject reductions of symbols in DLT relative relocs,
8508      relocations with plabels.  */
8509   if (hppa_fix->fx_r_field == e_tsel
8510       || hppa_fix->fx_r_field == e_ltsel
8511       || hppa_fix->fx_r_field == e_rtsel
8512       || hppa_fix->fx_r_field == e_psel
8513       || hppa_fix->fx_r_field == e_rpsel
8514       || hppa_fix->fx_r_field == e_lpsel)
8515     return 0;
8516
8517   /* Reject absolute calls (jumps).  */
8518   if (hppa_fix->fx_r_type == R_HPPA_ABS_CALL)
8519     return 0;
8520
8521   /* Reject reductions of function symbols.  */
8522   if (fixp->fx_addsy != 0 && S_IS_FUNCTION (fixp->fx_addsy))
8523     return 0;
8524
8525   return 1;
8526 }
8527
8528 /* Return nonzero if the fixup in FIXP will require a relocation,
8529    even it if appears that the fixup could be completely handled
8530    within GAS.  */
8531
8532 int
8533 hppa_force_relocation (fixp)
8534      struct fix *fixp;
8535 {
8536   struct hppa_fix_struct *hppa_fixp;
8537
8538   hppa_fixp = (struct hppa_fix_struct *) fixp->tc_fix_data;
8539 #ifdef OBJ_SOM
8540   if (fixp->fx_r_type == (int) R_HPPA_ENTRY
8541       || fixp->fx_r_type == (int) R_HPPA_EXIT
8542       || fixp->fx_r_type == (int) R_HPPA_BEGIN_BRTAB
8543       || fixp->fx_r_type == (int) R_HPPA_END_BRTAB
8544       || fixp->fx_r_type == (int) R_HPPA_BEGIN_TRY
8545       || fixp->fx_r_type == (int) R_HPPA_END_TRY
8546       || (fixp->fx_addsy != NULL && fixp->fx_subsy != NULL
8547           && (hppa_fixp->segment->flags & SEC_CODE) != 0))
8548     return 1;
8549 #endif
8550 #ifdef OBJ_ELF
8551   if (fixp->fx_r_type == (int) R_PARISC_GNU_VTINHERIT
8552       || fixp->fx_r_type == (int) R_PARISC_GNU_VTENTRY)
8553     return 1;
8554 #endif
8555
8556   assert (fixp->fx_addsy != NULL);
8557
8558   /* Ensure we emit a relocation for global symbols so that dynamic
8559      linking works.  */
8560   if (S_FORCE_RELOC (fixp->fx_addsy, 1))
8561     return 1;
8562
8563   /* It is necessary to force PC-relative calls/jumps to have a relocation
8564      entry if they're going to need either an argument relocation or long
8565      call stub.  */
8566   if (fixp->fx_pcrel
8567       && arg_reloc_stub_needed (symbol_arg_reloc_info (fixp->fx_addsy),
8568                                 hppa_fixp->fx_arg_reloc))
8569     return 1;
8570
8571   /* Now check to see if we're going to need a long-branch stub.  */
8572   if (fixp->fx_r_type == (int) R_HPPA_PCREL_CALL)
8573     {
8574       long pc = md_pcrel_from (fixp);
8575       valueT distance, min_stub_distance;
8576
8577       distance = fixp->fx_offset + S_GET_VALUE (fixp->fx_addsy) - pc - 8;
8578
8579       /* Distance to the closest possible stub.  This will detect most
8580          but not all circumstances where a stub will not work.  */
8581       min_stub_distance = pc + 16;
8582 #ifdef OBJ_SOM
8583       if (last_call_info != NULL)
8584         min_stub_distance -= S_GET_VALUE (last_call_info->start_symbol);
8585 #endif
8586
8587       if ((distance + 8388608 >= 16777216
8588            && min_stub_distance <= 8388608)
8589           || (hppa_fixp->fx_r_format == 17
8590               && distance + 262144 >= 524288
8591               && min_stub_distance <= 262144)
8592           || (hppa_fixp->fx_r_format == 12
8593               && distance + 8192 >= 16384
8594               && min_stub_distance <= 8192)
8595           )
8596         return 1;
8597     }
8598
8599   if (fixp->fx_r_type == (int) R_HPPA_ABS_CALL)
8600     return 1;
8601
8602   /* No need (yet) to force another relocations to be emitted.  */
8603   return 0;
8604 }
8605
8606 /* Now for some ELF specific code.  FIXME.  */
8607 #ifdef OBJ_ELF
8608 /* Mark the end of a function so that it's possible to compute
8609    the size of the function in elf_hppa_final_processing.  */
8610
8611 static void
8612 hppa_elf_mark_end_of_function ()
8613 {
8614   /* ELF does not have EXIT relocations.  All we do is create a
8615      temporary symbol marking the end of the function.  */
8616   char *name;
8617
8618   if (last_call_info == NULL || last_call_info->start_symbol == NULL)
8619     {
8620       /* We have already warned about a missing label,
8621          or other problems.  */
8622       return;
8623     }
8624
8625   name = (char *) xmalloc (strlen ("L$\001end_")
8626                            + strlen (S_GET_NAME (last_call_info->start_symbol))
8627                            + 1);
8628   if (name)
8629     {
8630       symbolS *symbolP;
8631
8632       strcpy (name, "L$\001end_");
8633       strcat (name, S_GET_NAME (last_call_info->start_symbol));
8634
8635       /* If we have a .exit followed by a .procend, then the
8636          symbol will have already been defined.  */
8637       symbolP = symbol_find (name);
8638       if (symbolP)
8639         {
8640           /* The symbol has already been defined!  This can
8641              happen if we have a .exit followed by a .procend.
8642
8643              This is *not* an error.  All we want to do is free
8644              the memory we just allocated for the name and continue.  */
8645           xfree (name);
8646         }
8647       else
8648         {
8649           /* symbol value should be the offset of the
8650              last instruction of the function */
8651           symbolP = symbol_new (name, now_seg, (valueT) (frag_now_fix () - 4),
8652                                 frag_now);
8653
8654           assert (symbolP);
8655           S_CLEAR_EXTERNAL (symbolP);
8656           symbol_table_insert (symbolP);
8657         }
8658
8659       if (symbolP)
8660         last_call_info->end_symbol = symbolP;
8661       else
8662         as_bad (_("Symbol '%s' could not be created."), name);
8663
8664     }
8665   else
8666     as_bad (_("No memory for symbol name."));
8667
8668 }
8669
8670 /* For ELF, this function serves one purpose:  to setup the st_size
8671    field of STT_FUNC symbols.  To do this, we need to scan the
8672    call_info structure list, determining st_size in by taking the
8673    difference in the address of the beginning/end marker symbols.  */
8674
8675 void
8676 elf_hppa_final_processing ()
8677 {
8678   struct call_info *call_info_pointer;
8679
8680   for (call_info_pointer = call_info_root;
8681        call_info_pointer;
8682        call_info_pointer = call_info_pointer->ci_next)
8683     {
8684       elf_symbol_type *esym
8685         = ((elf_symbol_type *)
8686            symbol_get_bfdsym (call_info_pointer->start_symbol));
8687       esym->internal_elf_sym.st_size =
8688         S_GET_VALUE (call_info_pointer->end_symbol)
8689         - S_GET_VALUE (call_info_pointer->start_symbol) + 4;
8690     }
8691 }
8692
8693 static void
8694 pa_vtable_entry (ignore)
8695      int ignore ATTRIBUTE_UNUSED;
8696 {
8697   struct fix *new_fix;
8698
8699   new_fix = obj_elf_vtable_entry (0);
8700
8701   if (new_fix)
8702     {
8703       struct hppa_fix_struct *hppa_fix = (struct hppa_fix_struct *)
8704         obstack_alloc (&notes, sizeof (struct hppa_fix_struct));
8705       hppa_fix->fx_r_type = R_HPPA;
8706       hppa_fix->fx_r_field = e_fsel;
8707       hppa_fix->fx_r_format = 32;
8708       hppa_fix->fx_arg_reloc = 0;
8709       hppa_fix->segment = now_seg;
8710       new_fix->tc_fix_data = (void *) hppa_fix;
8711       new_fix->fx_r_type = (int) R_PARISC_GNU_VTENTRY;
8712     }
8713 }
8714
8715 static void
8716 pa_vtable_inherit (ignore)
8717      int ignore ATTRIBUTE_UNUSED;
8718 {
8719   struct fix *new_fix;
8720
8721   new_fix = obj_elf_vtable_inherit (0);
8722
8723   if (new_fix)
8724     {
8725       struct hppa_fix_struct *hppa_fix = (struct hppa_fix_struct *)
8726         obstack_alloc (&notes, sizeof (struct hppa_fix_struct));
8727       hppa_fix->fx_r_type = R_HPPA;
8728       hppa_fix->fx_r_field = e_fsel;
8729       hppa_fix->fx_r_format = 32;
8730       hppa_fix->fx_arg_reloc = 0;
8731       hppa_fix->segment = now_seg;
8732       new_fix->tc_fix_data = (void *) hppa_fix;
8733       new_fix->fx_r_type = (int) R_PARISC_GNU_VTINHERIT;
8734     }
8735 }
8736 #endif