gas/config/tc-hppa.c

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