gas/config/tc-hppa.c

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