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