gas/config/tc-hppa.c

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