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