gas/config/tc-hppa.c

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