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