gas/config/tc-hppa.c

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