gas/config/tc-hppa.c

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