gas/config/tc-hppa.c

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