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