gas/config/tc-hppa.c

   1 /* tc-hppa.c -- Assemble for the PA
   2    Copyright (C) 1989 Free Software Foundation, Inc.
   3
   4    This file is part of GAS, the GNU Assembler.
   5
   6    GAS is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 1, or (at your option)
   9    any later version.
  10
  11    GAS is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GAS; see the file COPYING.  If not, write to
  18    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20
  21 /* HP PA-RISC support was contributed by the Center for Software Science
  22    at the University of Utah.  */
  23
  24 #include <stdio.h>
  25 #include <ctype.h>
  26
  27 #include "as.h"
  28 #include "subsegs.h"
  29
  30 #include "../bfd/libhppa.h"
  31 #include "../bfd/libbfd.h"
  32
  33 /* Be careful, this file includes data *declarations*.  */
  34 #include "opcode/hppa.h"
  35
  36 /* A "convient" place to put object file dependencies which do
  37    not need to be seen outside of tc-hppa.c.  */
  38 #ifdef OBJ_ELF
  39 /* Names of various debugging spaces/subspaces.  */
  40 #define GDB_DEBUG_SPACE_NAME ".stab"
  41 #define GDB_STRINGS_SUBSPACE_NAME ".stabstr"
  42 #define GDB_SYMBOLS_SUBSPACE_NAME ".stab"
  43 #define UNWIND_SECTION_NAME ".hppa_unwind"
  44 /* Nonzero if CODE is a fixup code needing further processing.  */
  45
  46 /* Object file formats specify relocation types.  */
  47 typedef elf32_hppa_reloc_type reloc_type;
  48
  49 /* Object file formats specify BFD symbol types.  */
  50 typedef elf_symbol_type obj_symbol_type;
  51
  52 /* How to generate a relocation.  */
  53 #define hppa_gen_reloc_type hppa_elf_gen_reloc_type
  54
  55 /* Who knows.  */
  56 #define obj_version obj_elf_version
  57
  58 /* Some local functions only used by ELF.  */
  59 static void pa_build_symextn_section PARAMS ((void));
  60 static void hppa_tc_make_symextn_section PARAMS ((void));
  61 #endif
  62
  63 #ifdef OBJ_SOM
  64 /* Names of various debugging spaces/subspaces.  */
  65 #define GDB_DEBUG_SPACE_NAME "$GDB_DEBUG$"
  66 #define GDB_STRINGS_SUBSPACE_NAME "$GDB_STRINGS$"
  67 #define GDB_SYMBOLS_SUBSPACE_NAME "$GDB_SYMBOLS$"
  68 #define UNWIND_SECTION_NAME "$UNWIND$"
  69
  70 /* Object file formats specify relocation types.  */
  71 typedef int reloc_type;
  72
  73 /* Who knows.  */
  74 #define obj_version obj_som_version
  75
  76 /* How to generate a relocation.  */
  77 #define hppa_gen_reloc_type hppa_som_gen_reloc_type
  78
  79 /* Object file formats specify BFD symbol types.  */
  80 typedef som_symbol_type obj_symbol_type;
  81 #endif
  82
  83 /* Various structures and types used internally in tc-hppa.c.  */
  84
  85 /* Unwind table and descriptor.  FIXME: Sync this with GDB version.  */
  86
  87 struct unwind_desc
  88   {
  89     unsigned int cannot_unwind:1;
  90     unsigned int millicode:1;
  91     unsigned int millicode_save_rest:1;
  92     unsigned int region_desc:2;
  93     unsigned int save_sr:2;
  94     unsigned int entry_fr:4;
  95     unsigned int entry_gr:5;
  96     unsigned int args_stored:1;
  97     unsigned int call_fr:5;
  98     unsigned int call_gr:5;
  99     unsigned int save_sp:1;
 100     unsigned int save_rp:1;
 101     unsigned int save_rp_in_frame:1;
 102     unsigned int extn_ptr_defined:1;
 103     unsigned int cleanup_defined:1;
 104
 105     unsigned int hpe_interrupt_marker:1;
 106     unsigned int hpux_interrupt_marker:1;
 107     unsigned int reserved:3;
 108     unsigned int frame_size:27;
 109   };
 110
 111 struct unwind_table
 112   {
 113     /* Starting and ending offsets of the region described by
 114        descriptor.  */
 115     unsigned int start_offset;
 116     unsigned int end_offset;
 117     struct unwind_desc descriptor;
 118   };
 119
 120 /* This structure is used by the .callinfo, .enter, .leave pseudo-ops to
 121    control the entry and exit code they generate. It is also used in
 122    creation of the correct stack unwind descriptors.
 123
 124    NOTE:  GAS does not support .enter and .leave for the generation of
 125    prologues and epilogues.  FIXME.
 126
 127    The fields in structure roughly correspond to the arguments available on the
 128    .callinfo pseudo-op.  */
 129
 130 struct call_info
 131   {
 132     /* Size of the stack frame.  */
 133     int frame;
 134
 135     /* Should sr3 be saved in the prologue?  */
 136     int entry_sr;
 137
 138     /* Does this function make calls?  */
 139     int makes_calls;
 140
 141     /* The unwind descriptor being built.  */
 142     struct unwind_table ci_unwind;
 143
 144     /* Name of this function.  */
 145     symbolS *start_symbol;
 146
 147     /* (temporary) symbol used to mark the end of this function.  */
 148     symbolS *end_symbol;
 149
 150     /* frags associated with start and end of this function.  */
 151     fragS *start_frag;
 152     fragS *end_frag;
 153
 154     /* frags for starting/ending offset of this descriptor.  */
 155     fragS *start_offset_frag;
 156     fragS *end_offset_frag;
 157
 158     /* The location within {start,end}_offset_frag to find the
 159        {start,end}_offset.  */
 160     int start_frag_where;
 161     int end_frag_where;
 162
 163     /* Fixups (relocations) for start_offset and end_offset.  */
 164     fixS *start_fix;
 165     fixS *end_fix;
 166
 167     /* Next entry in the chain.  */
 168     struct call_info *ci_next;
 169   };
 170
 171 /* Operand formats for FP instructions.   Note not all FP instructions
 172    allow all four formats to be used (for example fmpysub only allows
 173    SGL and DBL).  */
 174 typedef enum
 175   {
 176     SGL, DBL, ILLEGAL_FMT, QUAD
 177   }
 178 fp_operand_format;
 179
 180 /* This structure contains information needed to assemble
 181    individual instructions.  */
 182 struct pa_it
 183   {
 184     /* Holds the opcode after parsing by pa_ip.  */
 185     unsigned long opcode;
 186
 187     /* Holds an expression associated with the current instruction.  */
 188     expressionS exp;
 189
 190     /* Does this instruction use PC-relative addressing.  */
 191     int pcrel;
 192
 193     /* Floating point formats for operand1 and operand2.  */
 194     fp_operand_format fpof1;
 195     fp_operand_format fpof2;
 196
 197     /* Holds the field selector for this instruction
 198        (for example L%, LR%, etc).  */
 199     long field_selector;
 200
 201     /* Holds any argument relocation bits associated with this
 202        instruction.  (instruction should be some sort of call).  */
 203     long arg_reloc;
 204
 205     /* The format specification for this instruction.  */
 206     int format;
 207
 208     /* The relocation (if any) associated with this instruction.  */
 209     reloc_type reloc;
 210   };
 211
 212 /* PA-89 floating point registers are arranged like this:
 213
 214
 215    +--------------+--------------+
 216    |   0 or 16L   |  16 or 16R   |
 217    +--------------+--------------+
 218    |   1 or 17L   |  17 or 17R   |
 219    +--------------+--------------+
 220    |              |              |
 221
 222    .              .              .
 223    .              .              .
 224    .              .              .
 225
 226    |              |              |
 227    +--------------+--------------+
 228    |  14 or 30L   |  30 or 30R   |
 229    +--------------+--------------+
 230    |  15 or 31L   |  31 or 31R   |
 231    +--------------+--------------+
 232
 233
 234    The following is a version of pa_parse_number that
 235    handles the L/R notation and returns the correct
 236    value to put into the instruction register field.
 237    The correct value to put into the instruction is
 238    encoded in the structure 'pa_89_fp_reg_struct'.  */
 239
 240 struct pa_89_fp_reg_struct
 241   {
 242     /* The register number.  */
 243     char number_part;
 244
 245     /* L/R selector.  */
 246     char l_r_select;
 247   };
 248
 249 /* Additional information needed to build argument relocation stubs.  */
 250 struct call_desc
 251   {
 252     /* The argument relocation specification.  */
 253     unsigned int arg_reloc;
 254
 255     /* Number of arguments.  */
 256     unsigned int arg_count;
 257   };
 258
 259 /* This structure defines an entry in the subspace dictionary
 260    chain.  */
 261
 262 struct subspace_dictionary_chain
 263   {
 264     /* Index of containing space.  */
 265     unsigned long ssd_space_index;
 266
 267     /* Which quadrant within the space this subspace should be loaded into.  */
 268     unsigned char ssd_quadrant;
 269
 270     /* Alignment (in bytes) for this subspace.  */
 271     unsigned long ssd_alignment;
 272
 273     /* Access control bits to determine read/write/execute permissions
 274        as well as gateway privilege promotions.  */
 275     unsigned char ssd_access_control_bits;
 276
 277     /* A sorting key so that it is possible to specify ordering of
 278        subspaces within a space.  */
 279     unsigned char ssd_sort_key;
 280
 281     /* Nonzero of this space should be zero filled.  */
 282     unsigned long ssd_zero;
 283
 284     /* Nonzero if this is a common subspace.  */
 285     unsigned char ssd_common;
 286
 287     /* Nonzero if this is a common subspace which allows symbols to be
 288        multiply defined.  */
 289     unsigned char ssd_dup_common;
 290
 291     /* Nonzero if this subspace is loadable.  Note loadable subspaces
 292        must be contained within loadable spaces; unloadable subspaces
 293        must be contained in unloadable spaces.  */
 294     unsigned char ssd_loadable;
 295
 296     /* Nonzero if this subspace contains only code.  */
 297     unsigned char ssd_code_only;
 298
 299     /* Starting offset of this subspace.  */
 300     unsigned long ssd_subspace_start;
 301
 302     /* Length of this subspace.  */
 303     unsigned long ssd_subspace_length;
 304
 305     /* Name of this subspace.  */
 306     char *ssd_name;
 307
 308     /* GAS segment and subsegment associated with this subspace.  */
 309     asection *ssd_seg;
 310     int ssd_subseg;
 311
 312     /* Index of this subspace within the subspace dictionary of the object
 313        file.  Not used until object file is written.  */
 314     int object_file_index;
 315
 316     /* The size of the last alignment request for this subspace.  */
 317     int ssd_last_align;
 318
 319     /* Next space in the subspace dictionary chain.  */
 320     struct subspace_dictionary_chain *ssd_next;
 321   };
 322
 323 typedef struct subspace_dictionary_chain ssd_chain_struct;
 324
 325 /* This structure defines an entry in the subspace dictionary
 326    chain.  */
 327
 328 struct space_dictionary_chain
 329   {
 330
 331     /* Holds the index into the string table of the name of this
 332        space.  */
 333     unsigned int sd_name_index;
 334
 335     /* Nonzero if the space is loadable.  */
 336     unsigned int sd_loadable;
 337
 338     /* Nonzero if this space has been defined by the user code or
 339        as a default space.  */
 340     unsigned int sd_defined;
 341
 342     /* Nonzero if this spaces has been defined by the user code.  */
 343     unsigned int sd_user_defined;
 344
 345     /* Nonzero if this space is not sharable.  */
 346     unsigned int sd_private;
 347
 348     /* The space number (or index).  */
 349     unsigned int sd_spnum;
 350
 351     /* The sort key for this space.  May be used to determine how to lay
 352        out the spaces within the object file.  */
 353     unsigned char sd_sort_key;
 354
 355     /* The name of this subspace.  */
 356     char *sd_name;
 357
 358     /* GAS segment to which this subspace corresponds.  */
 359     asection *sd_seg;
 360
 361     /* Current subsegment number being used.  */
 362     int sd_last_subseg;
 363
 364     /* The chain of subspaces contained within this space.  */
 365     ssd_chain_struct *sd_subspaces;
 366
 367     /* The next entry in the space dictionary chain.  */
 368     struct space_dictionary_chain *sd_next;
 369   };
 370
 371 typedef struct space_dictionary_chain sd_chain_struct;
 372
 373 /* Structure for previous label tracking.  Needed so that alignments,
 374    callinfo declarations, etc can be easily attached to a particular
 375    label.  */
 376 typedef struct label_symbol_struct
 377   {
 378     struct symbol *lss_label;
 379     sd_chain_struct *lss_space;
 380     struct label_symbol_struct *lss_next;
 381   }
 382 label_symbol_struct;
 383
 384 /* This structure defines attributes of the default subspace
 385    dictionary entries.  */
 386
 387 struct default_subspace_dict
 388   {
 389     /* Name of the subspace.  */
 390     char *name;
 391
 392     /* FIXME.  Is this still needed?  */
 393     char defined;
 394
 395     /* Nonzero if this subspace is loadable.  */
 396     char loadable;
 397
 398     /* Nonzero if this subspace contains only code.  */
 399     char code_only;
 400
 401     /* Nonzero if this is a common subspace.  */
 402     char common;
 403
 404     /* Nonzero if this is a common subspace which allows symbols
 405        to be multiply defined.  */
 406     char dup_common;
 407
 408     /* Nonzero if this subspace should be zero filled.  */
 409     char zero;
 410
 411     /* Sort key for this subspace.  */
 412     unsigned char sort;
 413
 414     /* Access control bits for this subspace.  Can represent RWX access
 415        as well as privilege level changes for gateways.  */
 416     int access;
 417
 418     /* Index of containing space.  */
 419     int space_index;
 420
 421     /* Alignment (in bytes) of this subspace.  */
 422     int alignment;
 423
 424     /* Quadrant within space where this subspace should be loaded.  */
 425     int quadrant;
 426
 427     /* An index into the default spaces array.  */
 428     int def_space_index;
 429
 430     /* An alias for this section (or NULL if no alias exists).  */
 431     char *alias;
 432
 433     /* Subsegment associated with this subspace.  */
 434     subsegT subsegment;
 435   };
 436
 437 /* This structure defines attributes of the default space
 438    dictionary entries.  */
 439
 440 struct default_space_dict
 441   {
 442     /* Name of the space.  */
 443     char *name;
 444
 445     /* Space number.  It is possible to identify spaces within
 446        assembly code numerically!  */
 447     int spnum;
 448
 449     /* Nonzero if this space is loadable.  */
 450     char loadable;
 451
 452     /* Nonzero if this space is "defined".  FIXME is still needed */
 453     char defined;
 454
 455     /* Nonzero if this space can not be shared.  */
 456     char private;
 457
 458     /* Sort key for this space.  */
 459     unsigned char sort;
 460
 461     /* Segment associated with this space.  */
 462     asection *segment;
 463
 464     /* An alias for this section (or NULL if no alias exists).  */
 465     char *alias;
 466   };
 467
 468 /* Extra information needed to perform fixups (relocations) on the PA.  */
 469 struct hppa_fix_struct
 470 {
 471     /* The field selector.  */
 472     int fx_r_field;
 473
 474     /* Type of fixup.  */
 475     int fx_r_type;
 476
 477     /* Format of fixup.  */
 478     int fx_r_format;
 479
 480     /* Argument relocation bits.  */
 481     long fx_arg_reloc;
 482
 483     /* The unwind descriptor associated with this fixup.  */
 484     char fx_unwind[8];
 485 };
 486
 487 /* Structure to hold information about predefined registers.  */
 488
 489 struct pd_reg
 490 {
 491   char *name;
 492   int value;
 493 };
 494
 495 /* This structure defines the mapping from a FP condition string
 496    to a condition number which can be recorded in an instruction.  */
 497 struct fp_cond_map
 498 {
 499   char *string;
 500   int cond;
 501 };
 502
 503 /* This structure defines a mapping from a field selector
 504    string to a field selector type.  */
 505 struct selector_entry
 506 {
 507   char *prefix;
 508   int field_selector;
 509 };
 510
 511 /* Prototypes for functions local to tc-hppa.c.  */
 512
 513 static fp_operand_format pa_parse_fp_format PARAMS ((char **s));
 514 static void pa_cons PARAMS ((int));
 515 static void pa_data PARAMS ((int));
 516 static void pa_desc PARAMS ((int));
 517 static void pa_float_cons PARAMS ((int));
 518 static void pa_fill PARAMS ((int));
 519 static void pa_lcomm PARAMS ((int));
 520 static void pa_lsym PARAMS ((int));
 521 static void pa_stringer PARAMS ((int));
 522 static void pa_text PARAMS ((int));
 523 static void pa_version PARAMS ((int));
 524 static int pa_parse_fp_cmp_cond PARAMS ((char **));
 525 static int get_expression PARAMS ((char *));
 526 static int pa_get_absolute_expression PARAMS ((char *));
 527 static int evaluate_absolute PARAMS ((expressionS, int));
 528 static unsigned int pa_build_arg_reloc PARAMS ((char *));
 529 static unsigned int pa_align_arg_reloc PARAMS ((unsigned int, unsigned int));
 530 static int pa_parse_nullif PARAMS ((char **));
 531 static int pa_parse_nonneg_cmpsub_cmpltr PARAMS ((char **, int));
 532 static int pa_parse_neg_cmpsub_cmpltr PARAMS ((char **, int));
 533 static int pa_parse_neg_add_cmpltr PARAMS ((char **, int));
 534 static int pa_parse_nonneg_add_cmpltr PARAMS ((char **, int));
 535 static void pa_block PARAMS ((int));
 536 static void pa_call PARAMS ((int));
 537 static void pa_call_args PARAMS ((struct call_desc *));
 538 static void pa_callinfo PARAMS ((int));
 539 static void pa_code PARAMS ((int));
 540 static void pa_comm PARAMS ((int));
 541 static void pa_copyright PARAMS ((int));
 542 static void pa_end PARAMS ((int));
 543 static void pa_enter PARAMS ((int));
 544 static void pa_entry PARAMS ((int));
 545 static void pa_equ PARAMS ((int));
 546 static void pa_exit PARAMS ((int));
 547 static void pa_export PARAMS ((int));
 548 static void pa_export_args PARAMS ((symbolS *));
 549 static void pa_import PARAMS ((int));
 550 static void pa_label PARAMS ((int));
 551 static void pa_leave PARAMS ((int));
 552 static void pa_origin PARAMS ((int));
 553 static void pa_proc PARAMS ((int));
 554 static void pa_procend PARAMS ((int));
 555 static void pa_space PARAMS ((int));
 556 static void pa_spnum PARAMS ((int));
 557 static void pa_subspace PARAMS ((int));
 558 static void pa_param PARAMS ((int));
 559 static void pa_undefine_label PARAMS ((void));
 560 static int need_89_opcode PARAMS ((struct pa_it *,
 561                                    struct pa_89_fp_reg_struct *));
 562 static int pa_parse_number PARAMS ((char **, struct pa_89_fp_reg_struct *));
 563 static label_symbol_struct *pa_get_label PARAMS ((void));
 564 static sd_chain_struct *create_new_space PARAMS ((char *, int, char,
 565                                                   char, char, char,
 566                                                   asection *, int));
 567 static ssd_chain_struct * create_new_subspace PARAMS ((sd_chain_struct *,
 568                                                        char *, char, char,
 569                                                        char, char, char,
 570                                                        char, int, int, int,
 571                                                        int, asection *));
 572 static ssd_chain_struct *update_subspace PARAMS ((char *, char, char, char,
 573                                                   char, char, char, int,
 574                                                   int, int, int, subsegT));
 575 static sd_chain_struct *is_defined_space PARAMS ((char *));
 576 static ssd_chain_struct *is_defined_subspace PARAMS ((char *, subsegT));
 577 static sd_chain_struct *pa_segment_to_space PARAMS ((asection *));
 578 static ssd_chain_struct * pa_subsegment_to_subspace PARAMS ((asection *,
 579                                                              subsegT));
 580 static sd_chain_struct *pa_find_space_by_number PARAMS ((int));
 581 static unsigned int pa_subspace_start PARAMS ((sd_chain_struct *, int));
 582 static void pa_ip PARAMS ((char *));
 583 static void fix_new_hppa PARAMS ((fragS *, int, short int, symbolS *,
 584                                   long, expressionS *, int,
 585                                   bfd_reloc_code_real_type, long,
 586                                   int, long, char *));
 587 static void md_apply_fix_1 PARAMS ((fixS *, long));
 588 static int is_end_of_statement PARAMS ((void));
 589 static int reg_name_search PARAMS ((char *));
 590 static int pa_chk_field_selector PARAMS ((char **));
 591 static int is_same_frag PARAMS ((fragS *, fragS *));
 592 static void pa_build_unwind_subspace PARAMS ((struct call_info *));
 593 static void process_exit PARAMS ((void));
 594 static sd_chain_struct *pa_parse_space_stmt PARAMS ((char *, int));
 595 static void pa_align_subseg PARAMS ((asection *, subsegT));
 596 static int log2 PARAMS ((int));
 597 static int pa_next_subseg PARAMS ((sd_chain_struct *));
 598 static unsigned int pa_stringer_aux PARAMS ((char *));
 599 static void pa_spaces_begin PARAMS ((void));
 600
 601
 602 /* File and gloally scoped variable declarations.  */
 603
 604 /* Root and final entry in the space chain.  */
 605 static sd_chain_struct *space_dict_root;
 606 static sd_chain_struct *space_dict_last;
 607
 608 /* The current space and subspace.  */
 609 static sd_chain_struct *current_space;
 610 static ssd_chain_struct *current_subspace;
 611
 612 /* Root of the call_info chain.  */
 613 static struct call_info *call_info_root;
 614
 615 /* The last call_info (for functions) structure
 616    seen so it can be associated with fixups and
 617    function labels.  */
 618 static struct call_info *last_call_info;
 619
 620 /* The last call description (for actual calls).  */
 621 static struct call_desc last_call_desc;
 622
 623 /* Relaxation isn't supported for the PA yet.  */
 624 const relax_typeS md_relax_table[] = {0};
 625
 626 /* Jumps are always the same size -- one instruction.  */
 627 int md_short_jump_size = 4;
 628 int md_long_jump_size = 4;
 629
 630 /* handle of the OPCODE hash table */
 631 static struct hash_control *op_hash = NULL;
 632
 633 /* This array holds the chars that always start a comment.  If the
 634    pre-processor is disabled, these aren't very useful.  */
 635 const char comment_chars[] = ";";
 636
 637 /* Table of pseudo ops for the PA.  FIXME -- how many of these
 638    are now redundant with the overall GAS and the object file
 639    dependent tables?  */
 640 const pseudo_typeS md_pseudo_table[] =
 641 {
 642   /* align pseudo-ops on the PA specify the actual alignment requested,
 643      not the log2 of the requested alignment.  */
 644   {"align", s_align_bytes, 8},
 645   {"ALIGN", s_align_bytes, 8},
 646   {"block", pa_block, 1},
 647   {"BLOCK", pa_block, 1},
 648   {"blockz", pa_block, 0},
 649   {"BLOCKZ", pa_block, 0},
 650   {"byte", pa_cons, 1},
 651   {"BYTE", pa_cons, 1},
 652   {"call", pa_call, 0},
 653   {"CALL", pa_call, 0},
 654   {"callinfo", pa_callinfo, 0},
 655   {"CALLINFO", pa_callinfo, 0},
 656   {"code", pa_code, 0},
 657   {"CODE", pa_code, 0},
 658   {"comm", pa_comm, 0},
 659   {"COMM", pa_comm, 0},
 660   {"copyright", pa_copyright, 0},
 661   {"COPYRIGHT", pa_copyright, 0},
 662   {"data", pa_data, 0},
 663   {"DATA", pa_data, 0},
 664   {"desc", pa_desc, 0},
 665   {"DESC", pa_desc, 0},
 666   {"double", pa_float_cons, 'd'},
 667   {"DOUBLE", pa_float_cons, 'd'},
 668   {"end", pa_end, 0},
 669   {"END", pa_end, 0},
 670   {"enter", pa_enter, 0},
 671   {"ENTER", pa_enter, 0},
 672   {"entry", pa_entry, 0},
 673   {"ENTRY", pa_entry, 0},
 674   {"equ", pa_equ, 0},
 675   {"EQU", pa_equ, 0},
 676   {"exit", pa_exit, 0},
 677   {"EXIT", pa_exit, 0},
 678   {"export", pa_export, 0},
 679   {"EXPORT", pa_export, 0},
 680   {"fill", pa_fill, 0},
 681   {"FILL", pa_fill, 0},
 682   {"float", pa_float_cons, 'f'},
 683   {"FLOAT", pa_float_cons, 'f'},
 684   {"half", pa_cons, 2},
 685   {"HALF", pa_cons, 2},
 686   {"import", pa_import, 0},
 687   {"IMPORT", pa_import, 0},
 688   {"int", pa_cons, 4},
 689   {"INT", pa_cons, 4},
 690   {"label", pa_label, 0},
 691   {"LABEL", pa_label, 0},
 692   {"lcomm", pa_lcomm, 0},
 693   {"LCOMM", pa_lcomm, 0},
 694   {"leave", pa_leave, 0},
 695   {"LEAVE", pa_leave, 0},
 696   {"long", pa_cons, 4},
 697   {"LONG", pa_cons, 4},
 698   {"lsym", pa_lsym, 0},
 699   {"LSYM", pa_lsym, 0},
 700   {"octa", pa_cons, 16},
 701   {"OCTA", pa_cons, 16},
 702   {"org", pa_origin, 0},
 703   {"ORG", pa_origin, 0},
 704   {"origin", pa_origin, 0},
 705   {"ORIGIN", pa_origin, 0},
 706   {"param", pa_param, 0},
 707   {"PARAM", pa_param, 0},
 708   {"proc", pa_proc, 0},
 709   {"PROC", pa_proc, 0},
 710   {"procend", pa_procend, 0},
 711   {"PROCEND", pa_procend, 0},
 712   {"quad", pa_cons, 8},
 713   {"QUAD", pa_cons, 8},
 714   {"reg", pa_equ, 1},
 715   {"REG", pa_equ, 1},
 716   {"short", pa_cons, 2},
 717   {"SHORT", pa_cons, 2},
 718   {"single", pa_float_cons, 'f'},
 719   {"SINGLE", pa_float_cons, 'f'},
 720   {"space", pa_space, 0},
 721   {"SPACE", pa_space, 0},
 722   {"spnum", pa_spnum, 0},
 723   {"SPNUM", pa_spnum, 0},
 724   {"string", pa_stringer, 0},
 725   {"STRING", pa_stringer, 0},
 726   {"stringz", pa_stringer, 1},
 727   {"STRINGZ", pa_stringer, 1},
 728   {"subspa", pa_subspace, 0},
 729   {"SUBSPA", pa_subspace, 0},
 730   {"text", pa_text, 0},
 731   {"TEXT", pa_text, 0},
 732   {"version", pa_version, 0},
 733   {"VERSION", pa_version, 0},
 734   {"word", pa_cons, 4},
 735   {"WORD", pa_cons, 4},
 736   {NULL, 0, 0}
 737 };
 738
 739 /* This array holds the chars that only start a comment at the beginning of
 740    a line.  If the line seems to have the form '# 123 filename'
 741    .line and .file directives will appear in the pre-processed output.
 742
 743    Note that input_file.c hand checks for '#' at the beginning of the
 744    first line of the input file.  This is because the compiler outputs
 745    #NO_APP at the beginning of its output.
 746
 747    Also note that '/*' will always start a comment.  */
 748 const char line_comment_chars[] = "#";
 749
 750 /* This array holds the characters which act as line separators.  */
 751 const char line_separator_chars[] = "!";
 752
 753 /* Chars that can be used to separate mant from exp in floating point nums.  */
 754 const char EXP_CHARS[] = "eE";
 755
 756 /* Chars that mean this number is a floating point constant.
 757    As in 0f12.456 or 0d1.2345e12.
 758
 759    Be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
 760    changed in read.c.  Ideally it shouldn't hae to know abou it at
 761    all, but nothing is ideal around here.  */
 762 const char FLT_CHARS[] = "rRsSfFdDxXpP";
 763
 764 static struct pa_it the_insn;
 765
 766 /* Points to the end of an expression just parsed by get_expressoin
 767    and friends.  FIXME.  This shouldn't be handled with a file-global
 768    variable.  */
 769 static char *expr_end;
 770
 771 /* Nonzero if a .callinfo appeared within the current procedure.  */
 772 static int callinfo_found;
 773
 774 /* Nonzero if the assembler is currently within a .entry/.exit pair.  */
 775 static int within_entry_exit;
 776
 777 /* Nonzero if the assembler has completed exit processing for the
 778    current procedure.  */
 779 static int exit_processing_complete;
 780
 781 /* Nonzero if the assembler is currently within a procedure definition.  */
 782 static int within_procedure;
 783
 784 /* Handle on strucutre which keep track of the last symbol
 785    seen in each subspace.  */
 786 static label_symbol_struct *label_symbols_rootp = NULL;
 787
 788 /* Holds the last field selector.  */
 789 static int hppa_field_selector;
 790
 791 /* Nonzero if errors are to be printed.  */
 792 static int print_errors = 1;
 793
 794 /* List of registers that are pre-defined:
 795
 796    Each general register has one predefined name of the form
 797    %r<REGNUM> which has the value <REGNUM>.
 798
 799    Space and control registers are handled in a similar manner,
 800    but use %sr<REGNUM> and %cr<REGNUM> as their predefined names.
 801
 802    Likewise for the floating point registers, but of the form
 803    %fr<REGNUM>.  Floating point registers have additional predefined
 804    names with 'L' and 'R' suffixes (e.g. %fr19L, %fr19R) which
 805    again have the value <REGNUM>.
 806
 807    Many registers also have synonyms:
 808
 809    %r26 - %r23 have %arg0 - %arg3 as synonyms
 810    %r28 - %r29 have %ret0 - %ret1 as synonyms
 811    %r30 has %sp as a synonym
 812
 813    Almost every control register has a synonym; they are not listed
 814    here for brevity.
 815
 816    The table is sorted. Suitable for searching by a binary search. */
 817
 818 static const struct pd_reg pre_defined_registers[] =
 819 {
 820   {"%arg0", 26},
 821   {"%arg1", 25},
 822   {"%arg2", 24},
 823   {"%arg3", 23},
 824   {"%cr0", 0},
 825   {"%cr10", 10},
 826   {"%cr11", 11},
 827   {"%cr12", 12},
 828   {"%cr13", 13},
 829   {"%cr14", 14},
 830   {"%cr15", 15},
 831   {"%cr16", 16},
 832   {"%cr17", 17},
 833   {"%cr18", 18},
 834   {"%cr19", 19},
 835   {"%cr20", 20},
 836   {"%cr21", 21},
 837   {"%cr22", 22},
 838   {"%cr23", 23},
 839   {"%cr24", 24},
 840   {"%cr25", 25},
 841   {"%cr26", 26},
 842   {"%cr27", 27},
 843   {"%cr28", 28},
 844   {"%cr29", 29},
 845   {"%cr30", 30},
 846   {"%cr31", 31},
 847   {"%cr8", 8},
 848   {"%cr9", 9},
 849   {"%eiem", 15},
 850   {"%eirr", 23},
 851   {"%fr0", 0},
 852   {"%fr0L", 0},
 853   {"%fr0R", 0},
 854   {"%fr1", 1},
 855   {"%fr10", 10},
 856   {"%fr10L", 10},
 857   {"%fr10R", 10},
 858   {"%fr11", 11},
 859   {"%fr11L", 11},
 860   {"%fr11R", 11},
 861   {"%fr12", 12},
 862   {"%fr12L", 12},
 863   {"%fr12R", 12},
 864   {"%fr13", 13},
 865   {"%fr13L", 13},
 866   {"%fr13R", 13},
 867   {"%fr14", 14},
 868   {"%fr14L", 14},
 869   {"%fr14R", 14},
 870   {"%fr15", 15},
 871   {"%fr15L", 15},
 872   {"%fr15R", 15},
 873   {"%fr16", 16},
 874   {"%fr16L", 16},
 875   {"%fr16R", 16},
 876   {"%fr17", 17},
 877   {"%fr17L", 17},
 878   {"%fr17R", 17},
 879   {"%fr18", 18},
 880   {"%fr18L", 18},
 881   {"%fr18R", 18},
 882   {"%fr19", 19},
 883   {"%fr19L", 19},
 884   {"%fr19R", 19},
 885   {"%fr1L", 1},
 886   {"%fr1R", 1},
 887   {"%fr2", 2},
 888   {"%fr20", 20},
 889   {"%fr20L", 20},
 890   {"%fr20R", 20},
 891   {"%fr21", 21},
 892   {"%fr21L", 21},
 893   {"%fr21R", 21},
 894   {"%fr22", 22},
 895   {"%fr22L", 22},
 896   {"%fr22R", 22},
 897   {"%fr23", 23},
 898   {"%fr23L", 23},
 899   {"%fr23R", 23},
 900   {"%fr24", 24},
 901   {"%fr24L", 24},
 902   {"%fr24R", 24},
 903   {"%fr25", 25},
 904   {"%fr25L", 25},
 905   {"%fr25R", 25},
 906   {"%fr26", 26},
 907   {"%fr26L", 26},
 908   {"%fr26R", 26},
 909   {"%fr27", 27},
 910   {"%fr27L", 27},
 911   {"%fr27R", 27},
 912   {"%fr28", 28},
 913   {"%fr28L", 28},
 914   {"%fr28R", 28},
 915   {"%fr29", 29},
 916   {"%fr29L", 29},
 917   {"%fr29R", 29},
 918   {"%fr2L", 2},
 919   {"%fr2R", 2},
 920   {"%fr3", 3},
 921   {"%fr30", 30},
 922   {"%fr30L", 30},
 923   {"%fr30R", 30},
 924   {"%fr31", 31},
 925   {"%fr31L", 31},
 926   {"%fr31R", 31},
 927   {"%fr3L", 3},
 928   {"%fr3R", 3},
 929   {"%fr4", 4},
 930   {"%fr4L", 4},
 931   {"%fr4R", 4},
 932   {"%fr5", 5},
 933   {"%fr5L", 5},
 934   {"%fr5R", 5},
 935   {"%fr6", 6},
 936   {"%fr6L", 6},
 937   {"%fr6R", 6},
 938   {"%fr7", 7},
 939   {"%fr7L", 7},
 940   {"%fr7R", 7},
 941   {"%fr8", 8},
 942   {"%fr8L", 8},
 943   {"%fr8R", 8},
 944   {"%fr9", 9},
 945   {"%fr9L", 9},
 946   {"%fr9R", 9},
 947   {"%hta", 25},
 948   {"%iir", 19},
 949   {"%ior", 21},
 950   {"%ipsw", 22},
 951   {"%isr", 20},
 952   {"%itmr", 16},
 953   {"%iva", 14},
 954   {"%pcoq", 18},
 955   {"%pcsq", 17},
 956   {"%pidr1", 8},
 957   {"%pidr2", 9},
 958   {"%pidr3", 12},
 959   {"%pidr4", 13},
 960   {"%ppda", 24},
 961   {"%r0", 0},
 962   {"%r1", 1},
 963   {"%r10", 10},
 964   {"%r11", 11},
 965   {"%r12", 12},
 966   {"%r13", 13},
 967   {"%r14", 14},
 968   {"%r15", 15},
 969   {"%r16", 16},
 970   {"%r17", 17},
 971   {"%r18", 18},
 972   {"%r19", 19},
 973   {"%r2", 2},
 974   {"%r20", 20},
 975   {"%r21", 21},
 976   {"%r22", 22},
 977   {"%r23", 23},
 978   {"%r24", 24},
 979   {"%r25", 25},
 980   {"%r26", 26},
 981   {"%r27", 27},
 982   {"%r28", 28},
 983   {"%r29", 29},
 984   {"%r3", 3},
 985   {"%r30", 30},
 986   {"%r31", 31},
 987   {"%r4", 4},
 988   {"%r4L", 4},
 989   {"%r4R", 4},
 990   {"%r5", 5},
 991   {"%r5L", 5},
 992   {"%r5R", 5},
 993   {"%r6", 6},
 994   {"%r6L", 6},
 995   {"%r6R", 6},
 996   {"%r7", 7},
 997   {"%r7L", 7},
 998   {"%r7R", 7},
 999   {"%r8", 8},
1000   {"%r8L", 8},
1001   {"%r8R", 8},
1002   {"%r9", 9},
1003   {"%r9L", 9},
1004   {"%r9R", 9},
1005   {"%rctr", 0},
1006   {"%ret0", 28},
1007   {"%ret1", 29},
1008   {"%sar", 11},
1009   {"%sp", 30},
1010   {"%sr0", 0},
1011   {"%sr1", 1},
1012   {"%sr2", 2},
1013   {"%sr3", 3},
1014   {"%sr4", 4},
1015   {"%sr5", 5},
1016   {"%sr6", 6},
1017   {"%sr7", 7},
1018   {"%tr0", 24},
1019   {"%tr1", 25},
1020   {"%tr2", 26},
1021   {"%tr3", 27},
1022   {"%tr4", 28},
1023   {"%tr5", 29},
1024   {"%tr6", 30},
1025   {"%tr7", 31}
1026 };
1027
1028 /* This table is sorted by order of the length of the string. This is
1029    so we check for <> before we check for <. If we had a <> and checked
1030    for < first, we would get a false match.  */
1031 static const struct fp_cond_map fp_cond_map [] =
1032 {
1033   {"false?", 0},
1034   {"false", 1},
1035   {"true?", 30},
1036   {"true", 31},
1037   {"!<=>", 3},
1038   {"!?>=", 8},
1039   {"!?<=", 16},
1040   {"!<>", 7},
1041   {"!>=", 11},
1042   {"!?>", 12},
1043   {"?<=", 14},
1044   {"!<=", 19},
1045   {"!?<", 20},
1046   {"?>=", 22},
1047   {"!?=", 24},
1048   {"!=t", 27},
1049   {"<=>", 29},
1050   {"=t", 5},
1051   {"?=", 6},
1052   {"?<", 10},
1053   {"<=", 13},
1054   {"!>", 15},
1055   {"?>", 18},
1056   {">=", 21},
1057   {"!<", 23},
1058   {"<>", 25},
1059   {"!=", 26},
1060   {"!?", 28},
1061   {"?", 2},
1062   {"=", 4},
1063   {"<", 9},
1064   {">", 17}
1065 };
1066
1067 static const struct selector_entry selector_table[] =
1068 {
1069   {"F'", e_fsel},
1070   {"F%", e_fsel},
1071   {"LS'", e_lssel},
1072   {"LS%", e_lssel},
1073   {"RS'", e_rssel},
1074   {"RS%", e_rssel},
1075   {"L'", e_lsel},
1076   {"L%", e_lsel},
1077   {"R'", e_rsel},
1078   {"R%", e_rsel},
1079   {"LD'", e_ldsel},
1080   {"LD%", e_ldsel},
1081   {"RD'", e_rdsel},
1082   {"RD%", e_rdsel},
1083   {"LR'", e_lrsel},
1084   {"LR%", e_lrsel},
1085   {"RR'", e_rrsel},
1086   {"RR%", e_rrsel},
1087   {"P'", e_psel},
1088   {"P%", e_psel},
1089   {"RP'", e_rpsel},
1090   {"RP%", e_rpsel},
1091   {"LP'", e_lpsel},
1092   {"LP%", e_lpsel},
1093   {"T'", e_tsel},
1094   {"T%", e_tsel},
1095   {"RT'", e_rtsel},
1096   {"RT%", e_rtsel},
1097   {"LT'", e_ltsel},
1098   {"LT%", e_ltsel},
1099   {NULL, e_fsel}
1100 };
1101
1102 /* default space and subspace dictionaries */
1103
1104 #define GDB_SYMBOLS          GDB_SYMBOLS_SUBSPACE_NAME
1105 #define GDB_STRINGS          GDB_STRINGS_SUBSPACE_NAME
1106
1107 /* pre-defined subsegments (subspaces) for the HPPA.  */
1108 #define SUBSEG_CODE   0
1109 #define SUBSEG_DATA   0
1110 #define SUBSEG_LIT    1
1111 #define SUBSEG_BSS    2
1112 #define SUBSEG_UNWIND 3
1113 #define SUBSEG_GDB_STRINGS 0
1114 #define SUBSEG_GDB_SYMBOLS 1
1115
1116 static struct default_subspace_dict pa_def_subspaces[] =
1117 {
1118   {"$CODE$", 1, 1, 1, 0, 0, 0, 24, 0x2c, 0, 8, 0, 0, ".text", SUBSEG_CODE},
1119   {"$DATA$", 1, 1, 0, 0, 0, 0, 24, 0x1f, 1, 8, 1, 1, ".data", SUBSEG_DATA},
1120   {"$LIT$", 1, 1, 0, 0, 0, 0, 16, 0x2c, 0, 8, 0, 0, ".text", SUBSEG_LIT},
1121   {"$BSS$", 1, 1, 0, 0, 0, 1, 80, 0x1f, 1, 8, 1, 1, ".bss", SUBSEG_BSS},
1122   {"$UNWIND$", 1, 1, 0, 0, 0, 0, 64, 0x2c, 0, 4, 0, 0, ".hppa_unwind", SUBSEG_UNWIND},
1123   {NULL, 0, 1, 0, 0, 0, 0, 255, 0x1f, 0, 4, 0, 0, 0}
1124 };
1125
1126 static struct default_space_dict pa_def_spaces[] =
1127 {
1128   {"$TEXT$", 0, 1, 1, 0, 8, ASEC_NULL, ".text"},
1129   {"$PRIVATE$", 1, 1, 1, 1, 16, ASEC_NULL, ".data"},
1130   {NULL, 0, 0, 0, 0, 0, ASEC_NULL, NULL}
1131 };
1132
1133 /* Misc local definitions used by the assembler.  */
1134
1135 /* Return nonzero if the string pointed to by S potentially represents
1136    a right or left half of a FP register  */
1137 #define IS_R_SELECT(S)   (*(S) == 'R' || *(S) == 'r')
1138 #define IS_L_SELECT(S)   (*(S) == 'L' || *(S) == 'l')
1139
1140 /* These macros are used to maintain spaces/subspaces.  */
1141 #define SPACE_DEFINED(space_chain)      (space_chain)->sd_defined
1142 #define SPACE_USER_DEFINED(space_chain) (space_chain)->sd_user_defined
1143 #define SPACE_PRIVATE(space_chain)      (space_chain)->sd_private
1144 #define SPACE_LOADABLE(space_chain)     (space_chain)->sd_loadable
1145 #define SPACE_SPNUM(space_chain)        (space_chain)->sd_spnum
1146 #define SPACE_SORT(space_chain)         (space_chain)->sd_sort_key
1147 #define SPACE_NAME(space_chain)         (space_chain)->sd_name
1148 #define SPACE_NAME_INDEX(space_chain)   (space_chain)->sd_name_index
1149
1150 #define SUBSPACE_SPACE_INDEX(ss_chain)  (ss_chain)->ssd_space_index
1151 #define SUBSPACE_QUADRANT(ss_chain)     (ss_chain)->ssd_quadrant
1152 #define SUBSPACE_ALIGN(ss_chain)        (ss_chain)->ssd_alignment
1153 #define SUBSPACE_ACCESS(ss_chain)       (ss_chain)->ssd_access_control_bits
1154 #define SUBSPACE_SORT(ss_chain)         (ss_chain)->ssd_sort_key
1155 #define SUBSPACE_COMMON(ss_chain)       (ss_chain)->ssd_common
1156 #define SUBSPACE_ZERO(ss_chain)         (ss_chain)->ssd_zero
1157 #define SUBSPACE_DUP_COMM(ss_chain)     (ss_chain)->ssd_dup_common
1158 #define SUBSPACE_CODE_ONLY(ss_chain)    (ss_chain)->ssd_code_only
1159 #define SUBSPACE_LOADABLE(ss_chain)     (ss_chain)->ssd_loadable
1160 #define SUBSPACE_SUBSPACE_START(ss_chain) (ss_chain)->ssd_subspace_start
1161 #define SUBSPACE_SUBSPACE_LENGTH(ss_chain) (ss_chain)->ssd_subspace_length
1162 #define SUBSPACE_NAME(ss_chain)         (ss_chain)->ssd_name
1163
1164 #define is_DP_relative(exp)                     \
1165   ((exp).X_op == O_subtract                     \
1166    && strcmp((exp).X_op_symbol->bsym->name, "$global$") == 0)
1167
1168 #define is_PC_relative(exp)                     \
1169   ((exp).X_op == O_subtract                     \
1170    && strcmp((exp).X_op_symbol->bsym->name, "$PIC_pcrel$0") == 0)
1171
1172 #define is_complex(exp)                         \
1173   ((exp).X_op != O_constant && (exp).X_op != O_symbol)
1174
1175 /* Actual functions to implement the PA specific code for the assembler.  */
1176
1177 /* Returns a pointer to the label_symbol_struct for the current space.
1178    or NULL if no label_symbol_struct exists for the current space.  */
1179
1180 static label_symbol_struct *
1181 pa_get_label ()
1182 {
1183   label_symbol_struct *label_chain;
1184   sd_chain_struct *space_chain = pa_segment_to_space (now_seg);
1185
1186   for (label_chain = label_symbols_rootp;
1187        label_chain;
1188        label_chain = label_chain->lss_next)
1189     if (space_chain == label_chain->lss_space && label_chain->lss_label)
1190       return label_chain;
1191
1192   return NULL;
1193 }
1194
1195 /* Defines a label for the current space.  If one is already defined,
1196    this function will replace it with the new label.  */
1197
1198 void
1199 pa_define_label (symbol)
1200      symbolS *symbol;
1201 {
1202   label_symbol_struct *label_chain = pa_get_label ();
1203   sd_chain_struct *space_chain = pa_segment_to_space (now_seg);
1204
1205   if (label_chain)
1206     label_chain->lss_label = symbol;
1207   else
1208     {
1209       /* Create a new label entry and add it to the head of the chain.  */
1210       label_chain
1211         = (label_symbol_struct *) xmalloc (sizeof (label_symbol_struct));
1212       label_chain->lss_label = symbol;
1213       label_chain->lss_space = space_chain;
1214       label_chain->lss_next = NULL;
1215
1216       if (label_symbols_rootp)
1217         label_chain->lss_next = label_symbols_rootp;
1218
1219       label_symbols_rootp = label_chain;
1220     }
1221 }
1222
1223 /* Removes a label definition for the current space.
1224    If there is no label_symbol_struct entry, then no action is taken.  */
1225
1226 static void
1227 pa_undefine_label ()
1228 {
1229   label_symbol_struct *label_chain;
1230   label_symbol_struct *prev_label_chain = NULL;
1231   sd_chain_struct *space_chain = pa_segment_to_space (now_seg);
1232
1233   for (label_chain = label_symbols_rootp;
1234        label_chain;
1235        label_chain = label_chain->lss_next)
1236     {
1237       if (space_chain == label_chain->lss_space && label_chain->lss_label)
1238         {
1239           /* Remove the label from the chain and free its memory.  */
1240           if (prev_label_chain)
1241             prev_label_chain->lss_next = label_chain->lss_next;
1242           else
1243             label_symbols_rootp = label_chain->lss_next;
1244
1245           free (label_chain);
1246           break;
1247         }
1248       prev_label_chain = label_chain;
1249     }
1250 }
1251
1252
1253 /* An HPPA-specific version of fix_new.  This is required because the HPPA
1254    code needs to keep track of some extra stuff.  Each call to fix_new_hppa
1255    results in the creation of an instance of an hppa_fix_struct.  An
1256    hppa_fix_struct stores the extra information along with a pointer to the
1257    original fixS.  This is attached to the original fixup via the
1258    tc_fix_data field.  */
1259
1260 static void
1261 fix_new_hppa (frag, where, size, add_symbol, offset, exp, pcrel,
1262               r_type, r_field, r_format, arg_reloc, unwind_desc)
1263      fragS *frag;
1264      int where;
1265      short int size;
1266      symbolS *add_symbol;
1267      long offset;
1268      expressionS *exp;
1269      int pcrel;
1270      bfd_reloc_code_real_type r_type;
1271      long r_field;
1272      int r_format;
1273      long arg_reloc;
1274      char *unwind_desc;
1275 {
1276   fixS *new_fix;
1277
1278   struct hppa_fix_struct *hppa_fix = (struct hppa_fix_struct *)
1279     obstack_alloc (&notes, sizeof (struct hppa_fix_struct));
1280
1281   if (exp != NULL)
1282     new_fix = fix_new_exp (frag, where, size, exp, pcrel, r_type);
1283   else
1284     new_fix = fix_new (frag, where, size, add_symbol, offset, pcrel, r_type);
1285   new_fix->tc_fix_data = hppa_fix;
1286   hppa_fix->fx_r_type = r_type;
1287   hppa_fix->fx_r_field = r_field;
1288   hppa_fix->fx_r_format = r_format;
1289   hppa_fix->fx_arg_reloc = arg_reloc;
1290   if (unwind_desc)
1291     bcopy (unwind_desc, hppa_fix->fx_unwind, 8);
1292
1293 }
1294
1295 /* Parse a .byte, .word, .long expression for the HPPA.  Called by
1296    cons via the TC_PARSE_CONS_EXPRESSION macro.  */
1297
1298 void
1299 parse_cons_expression_hppa (exp)
1300      expressionS *exp;
1301 {
1302   hppa_field_selector = pa_chk_field_selector (&input_line_pointer);
1303   expression (exp);
1304 }
1305
1306 /* This fix_new is called by cons via TC_CONS_FIX_NEW.
1307    hppa_field_selector is set by the parse_cons_expression_hppa.  */
1308
1309 void
1310 cons_fix_new_hppa (frag, where, size, exp)
1311      fragS *frag;
1312      int where;
1313      int size;
1314      expressionS *exp;
1315 {
1316   unsigned int reloc_type;
1317
1318   if (is_DP_relative (*exp))
1319     reloc_type = R_HPPA_GOTOFF;
1320   else if (is_complex (*exp))
1321     reloc_type = R_HPPA_COMPLEX;
1322   else
1323     reloc_type = R_HPPA;
1324
1325   if (hppa_field_selector != e_psel && hppa_field_selector != e_fsel)
1326     as_warn ("Invalid field selector.  Assuming F%%.");
1327
1328   fix_new_hppa (frag, where, size,
1329                 (symbolS *) NULL, (offsetT) 0, exp, 0, reloc_type,
1330                 hppa_field_selector, 32, 0, (char *) 0);
1331 }
1332
1333 /* This function is called once, at assembler startup time.  It should
1334    set up all the tables, etc. that the MD part of the assembler will need.  */
1335
1336 void
1337 md_begin ()
1338 {
1339   char *retval = NULL;
1340   int lose = 0;
1341   unsigned int i = 0;
1342
1343   last_call_info = NULL;
1344   call_info_root = NULL;
1345
1346   /* Folding of text and data segments fails miserably on the PA.
1347      Warn user and disable "-R" option.  */
1348   if (flagseen['R'])
1349     {
1350       as_warn ("-R option not supported on this target.");
1351       flag_readonly_data_in_text = 0;
1352       flagseen['R'] = 0;
1353     }
1354
1355   pa_spaces_begin ();
1356
1357   op_hash = hash_new ();
1358   if (op_hash == NULL)
1359     as_fatal ("Virtual memory exhausted");
1360
1361   while (i < NUMOPCODES)
1362     {
1363       const char *name = pa_opcodes[i].name;
1364       retval = hash_insert (op_hash, name, &pa_opcodes[i]);
1365       if (retval != NULL && *retval != '\0')
1366         {
1367           as_fatal ("Internal error: can't hash `%s': %s\n", name, retval);
1368           lose = 1;
1369         }
1370       do
1371         {
1372           if ((pa_opcodes[i].match & pa_opcodes[i].mask)
1373               != pa_opcodes[i].match)
1374             {
1375               fprintf (stderr, "internal error: losing opcode: `%s' \"%s\"\n",
1376                        pa_opcodes[i].name, pa_opcodes[i].args);
1377               lose = 1;
1378             }
1379           ++i;
1380         }
1381       while (i < NUMOPCODES && !strcmp (pa_opcodes[i].name, name));
1382     }
1383
1384   if (lose)
1385     as_fatal ("Broken assembler.  No assembly attempted.");
1386 }
1387
1388 /* Called at the end of assembling a source file.  Nothing to do
1389    at this point on the PA.  */
1390
1391 void
1392 md_end ()
1393 {
1394   return;
1395 }
1396
1397 /* Assemble a single instruction storing it into a frag.  */
1398 void
1399 md_assemble (str)
1400      char *str;
1401 {
1402   char *to;
1403
1404   /* The had better be something to assemble.  */
1405   assert (str);
1406
1407   /* Assemble the instruction.  Results are saved into "the_insn".  */
1408   pa_ip (str);
1409
1410   /* Get somewhere to put the assembled instrution.  */
1411   to = frag_more (4);
1412
1413   /* Output the opcode. */
1414   md_number_to_chars (to, the_insn.opcode, 4);
1415
1416   /* If necessary output more stuff.  */
1417   if (the_insn.reloc != R_HPPA_NONE)
1418     fix_new_hppa (frag_now, (to - frag_now->fr_literal), 4, NULL,
1419                   (offsetT) 0, &the_insn.exp, the_insn.pcrel,
1420                   the_insn.reloc, the_insn.field_selector,
1421                   the_insn.format, the_insn.arg_reloc, NULL);
1422
1423 }
1424
1425 /* Do the real work for assembling a single instruction.  Store results
1426    into the global "the_insn" variable.
1427
1428    FIXME:  Should define and use some functions/macros to handle
1429    various common insertions of information into the opcode.  */
1430
1431 static void
1432 pa_ip (str)
1433      char *str;
1434 {
1435   char *error_message = "";
1436   char *s, c, *argstart, *name, *save_s;
1437   const char *args;
1438   int match = FALSE;
1439   int comma = 0;
1440   int reg, s2, s3, m, a, uu, cmpltr, nullif, flag, sfu, cond;
1441   unsigned int im21, im14, im11, im5;
1442   unsigned long i, opcode;
1443   struct pa_opcode *insn;
1444
1445   /* Skip to something interesting.  */
1446   for (s = str; isupper (*s) || islower (*s) || (*s >= '0' && *s <= '3'); ++s)
1447     ;
1448
1449   switch (*s)
1450     {
1451
1452     case '\0':
1453       break;
1454
1455     case ',':
1456       comma = 1;
1457
1458       /*FALLTHROUGH */
1459
1460     case ' ':
1461       *s++ = '\0';
1462       break;
1463
1464     default:
1465       as_bad ("Unknown opcode: `%s'", str);
1466       exit (1);
1467     }
1468
1469   save_s = str;
1470
1471   /* Convert everything into lower case.  */
1472   while (*save_s)
1473     {
1474       if (isupper (*save_s))
1475         *save_s = tolower (*save_s);
1476       save_s++;
1477     }
1478
1479   /* Look up the opcode in the has table.  */
1480   if ((insn = (struct pa_opcode *) hash_find (op_hash, str)) == NULL)
1481     {
1482       as_bad ("Unknown opcode: `%s'", str);
1483       return;
1484     }
1485
1486   if (comma)
1487     {
1488       *--s = ',';
1489     }
1490
1491   /* Mark the location where arguments for the instruction start, then
1492      start processing them.  */
1493   argstart = s;
1494   for (;;)
1495     {
1496       /* Do some initialization.  */
1497       opcode = insn->match;
1498       bzero (&the_insn, sizeof (the_insn));
1499
1500       the_insn.reloc = R_HPPA_NONE;
1501
1502       /* Build the opcode, checking as we go to make
1503          sure that the operands match.  */
1504       for (args = insn->args;; ++args)
1505         {
1506           switch (*args)
1507             {
1508
1509             /* End of arguments.  */
1510             case '\0':
1511               if (*s == '\0')
1512                 match = TRUE;
1513               break;
1514
1515             case '+':
1516               if (*s == '+')
1517                 {
1518                   ++s;
1519                   continue;
1520                 }
1521               if (*s == '-')
1522                 continue;
1523               break;
1524
1525             /* These must match exactly.  */
1526             case '(':
1527             case ')':
1528             case ',':
1529             case ' ':
1530               if (*s++ == *args)
1531                 continue;
1532               break;
1533
1534             /* Handle a 5 bit register or control register field at 10.  */
1535             case 'b':
1536             case '^':
1537               reg = pa_parse_number (&s, 0);
1538               if (reg < 32 && reg >= 0)
1539                 {
1540                   opcode |= reg << 21;
1541                   continue;
1542                 }
1543               break;
1544
1545             /* Handle a 5 bit register field at 15.  */
1546             case 'x':
1547               reg = pa_parse_number (&s, 0);
1548               if (reg < 32 && reg >= 0)
1549                 {
1550                   opcode |= reg << 16;
1551                   continue;
1552                 }
1553               break;
1554
1555             /* Handle a 5 bit register field at 31.  */
1556             case 'y':
1557             case 't':
1558               reg = pa_parse_number (&s, 0);
1559               if (reg < 32 && reg >= 0)
1560                 {
1561                   opcode |= reg;
1562                   continue;
1563                 }
1564               break;
1565
1566             /* Handle a 5 bit field length at 31.  */
1567             case 'T':
1568               pa_get_absolute_expression (s);
1569               if (the_insn.exp.X_op == O_constant)
1570                 {
1571                   reg = the_insn.exp.X_add_number;
1572                   if (reg <= 32 && reg > 0)
1573                     {
1574                       opcode |= 32 - reg;
1575                       s = expr_end;
1576                       continue;
1577                     }
1578                 }
1579               break;
1580
1581             /* Handle a 5 bit immediate at 15.  */
1582             case '5':
1583               pa_get_absolute_expression (s);
1584               if (the_insn.exp.X_add_number > 15)
1585                 {
1586                   as_bad ("5 bit immediate > 15. Set to 15");
1587                   the_insn.exp.X_add_number = 15;
1588                 }
1589               else if (the_insn.exp.X_add_number < -16)
1590                 {
1591                   as_bad ("5 bit immediate < -16. Set to -16");
1592                   the_insn.exp.X_add_number = -16;
1593                 }
1594
1595               low_sign_unext (evaluate_absolute (the_insn.exp,
1596                                                  the_insn.field_selector),
1597                               5, &im5);
1598               opcode |= (im5 << 16);
1599               s = expr_end;
1600               continue;
1601
1602             /* Handle a 2 bit space identifier at 17.  */
1603             case 's':
1604               s2 = pa_parse_number (&s, 0);
1605               if (s2 < 4 && s2 >= 0)
1606                 {
1607                   opcode |= s2 << 14;
1608                   continue;
1609                 }
1610               break;
1611
1612             /* Handle a 3 bit space identifier at 18.  */
1613             case 'S':
1614               s3 = pa_parse_number (&s, 0);
1615               if (s3 < 8 && s3 >= 0)
1616                 {
1617                   dis_assemble_3 (s3, &s3);
1618                   opcode |= s3 << 13;
1619                   continue;
1620                 }
1621               break;
1622
1623             /* Handle a completer for an indexing load or store.  */
1624             case 'c':
1625               uu = 0;
1626               m = 0;
1627               i = 0;
1628               while (*s == ',' && i < 2)
1629                 {
1630                   s++;
1631                   if (strncasecmp (s, "sm", 2) == 0)
1632                     {
1633                       uu = 1;
1634                       m = 1;
1635                       s++;
1636                       i++;
1637                     }
1638                   else if (strncasecmp (s, "m", 1) == 0)
1639                     m = 1;
1640                   else if (strncasecmp (s, "s", 1) == 0)
1641                     uu = 1;
1642                   else
1643                     as_bad ("Invalid Indexed Load Completer.");
1644                   s++;
1645                   i++;
1646                 }
1647               if (i > 2)
1648                 as_bad ("Invalid Indexed Load Completer Syntax.");
1649               while (*s == ' ' || *s == '\t')
1650                 s++;
1651
1652               opcode |= m << 5;
1653               opcode |= uu << 13;
1654               continue;
1655
1656             /* Handle a short load/store completer.  */
1657             case 'C':
1658               a = 0;
1659               m = 0;
1660               if (*s == ',')
1661                 {
1662                   s++;
1663                   if (strncasecmp (s, "ma", 2) == 0)
1664                     {
1665                       a = 0;
1666                       m = 1;
1667                     }
1668                   else if (strncasecmp (s, "mb", 2) == 0)
1669                     {
1670                       a = 1;
1671                       m = 1;
1672                     }
1673                   else
1674                     as_bad ("Invalid Short Load/Store Completer.");
1675                   s += 2;
1676                 }
1677               while (*s == ' ' || *s == '\t')
1678                 s++;
1679               opcode |= m << 5;
1680               opcode |= a << 13;
1681               continue;
1682
1683             /* Handle a stbys completer.  */
1684             case 'Y':
1685               a = 0;
1686               m = 0;
1687               i = 0;
1688               while (*s == ',' && i < 2)
1689                 {
1690                   s++;
1691                   if (strncasecmp (s, "m", 1) == 0)
1692                     m = 1;
1693                   else if (strncasecmp (s, "b", 1) == 0)
1694                     a = 0;
1695                   else if (strncasecmp (s, "e", 1) == 0)
1696                     a = 1;
1697                   else
1698                     as_bad ("Invalid Store Bytes Short Completer");
1699                   s++;
1700                   i++;
1701                 }
1702               if (i > 2)
1703                 as_bad ("Invalid Store Bytes Short Completer");
1704               while (*s == ' ' || *s == '\t')
1705                 s++;
1706               opcode |= m << 5;
1707               opcode |= a << 13;
1708               continue;
1709
1710             /* Handle a non-negated compare/stubtract condition.  */
1711             case '<':
1712               cmpltr = pa_parse_nonneg_cmpsub_cmpltr (&s, 1);
1713               if (cmpltr < 0)
1714                 {
1715                   as_bad ("Invalid Compare/Subtract Condition: %c", *s);
1716                   cmpltr = 0;
1717                 }
1718               opcode |= cmpltr << 13;
1719               continue;
1720
1721             /* Handle a negated or non-negated compare/subtract condition.  */
1722             case '?':
1723               save_s = s;
1724               cmpltr = pa_parse_nonneg_cmpsub_cmpltr (&s, 1);
1725               if (cmpltr < 0)
1726                 {
1727                   s = save_s;
1728                   cmpltr = pa_parse_neg_cmpsub_cmpltr (&s, 1);
1729                   if (cmpltr < 0)
1730                     {
1731                       as_bad ("Invalid Compare/Subtract Condition.");
1732                       cmpltr = 0;
1733                     }
1734                   else
1735                     {
1736                       /* Negated condition requires an opcode change.  */
1737                       opcode |= 1 << 27;
1738                     }
1739                 }
1740               opcode |= cmpltr << 13;
1741               continue;
1742
1743             /* Handle a negated or non-negated add condition.  */
1744             case '!':
1745               save_s = s;
1746               cmpltr = pa_parse_nonneg_add_cmpltr (&s, 1);
1747               if (cmpltr < 0)
1748                 {
1749                   s = save_s;
1750                   cmpltr = pa_parse_neg_add_cmpltr (&s, 1);
1751                   if (cmpltr < 0)
1752                     {
1753                       as_bad ("Invalid Compare/Subtract Condition");
1754                       cmpltr = 0;
1755                     }
1756                   else
1757                     {
1758                       /* Negated condition requires an opcode change.  */
1759                       opcode |= 1 << 27;
1760                     }
1761                 }
1762               opcode |= cmpltr << 13;
1763               continue;
1764
1765             /* Handle a compare/subtract condition.  */
1766             case 'a':
1767               cmpltr = 0;
1768               flag = 0;
1769               save_s = s;
1770               if (*s == ',')
1771                 {
1772                   cmpltr = pa_parse_nonneg_cmpsub_cmpltr (&s, 0);
1773                   if (cmpltr < 0)
1774                     {
1775                       flag = 1;
1776                       s = save_s;
1777                       cmpltr = pa_parse_neg_cmpsub_cmpltr (&s, 0);
1778                       if (cmpltr < 0)
1779                         {
1780                           as_bad ("Invalid Compare/Subtract Condition");
1781                         }
1782                     }
1783                 }
1784               opcode |= cmpltr << 13;
1785               opcode |= flag << 12;
1786               continue;
1787
1788             /* Handle a non-negated add condition.  */
1789             case 'd':
1790               cmpltr = 0;
1791               nullif = 0;
1792               flag = 0;
1793               if (*s == ',')
1794                 {
1795                   s++;
1796                   name = s;
1797                   while (*s != ',' && *s != ' ' && *s != '\t')
1798                     s += 1;
1799                   c = *s;
1800                   *s = 0x00;
1801                   if (strcmp (name, "=") == 0)
1802                     cmpltr = 1;
1803                   else if (strcmp (name, "<") == 0)
1804                     cmpltr = 2;
1805                   else if (strcmp (name, "<=") == 0)
1806                     cmpltr = 3;
1807                   else if (strcasecmp (name, "nuv") == 0)
1808                     cmpltr = 4;
1809                   else if (strcasecmp (name, "znv") == 0)
1810                     cmpltr = 5;
1811                   else if (strcasecmp (name, "sv") == 0)
1812                     cmpltr = 6;
1813                   else if (strcasecmp (name, "od") == 0)
1814                     cmpltr = 7;
1815                   else if (strcasecmp (name, "n") == 0)
1816                     nullif = 1;
1817                   else if (strcasecmp (name, "tr") == 0)
1818                     {
1819                       cmpltr = 0;
1820                       flag = 1;
1821                     }
1822                   else if (strcasecmp (name, "<>") == 0)
1823                     {
1824                       cmpltr = 1;
1825                       flag = 1;
1826                     }
1827                   else if (strcasecmp (name, ">=") == 0)
1828                     {
1829                       cmpltr = 2;
1830                       flag = 1;
1831                     }
1832                   else if (strcasecmp (name, ">") == 0)
1833                     {
1834                       cmpltr = 3;
1835                       flag = 1;
1836                     }
1837                   else if (strcasecmp (name, "uv") == 0)
1838                     {
1839                       cmpltr = 4;
1840                       flag = 1;
1841                     }
1842                   else if (strcasecmp (name, "vnz") == 0)
1843                     {
1844                       cmpltr = 5;
1845                       flag = 1;
1846                     }
1847                   else if (strcasecmp (name, "nsv") == 0)
1848                     {
1849                       cmpltr = 6;
1850                       flag = 1;
1851                     }
1852                   else if (strcasecmp (name, "ev") == 0)
1853                     {
1854                       cmpltr = 7;
1855                       flag = 1;
1856                     }
1857                   else
1858                     as_bad ("Invalid Add Condition: %s", name);
1859                   *s = c;
1860                 }
1861               nullif = pa_parse_nullif (&s);
1862               opcode |= nullif << 1;
1863               opcode |= cmpltr << 13;
1864               opcode |= flag << 12;
1865               continue;
1866
1867             /* Handle a logical instruction condition.  */
1868             case '&':
1869               cmpltr = 0;
1870               flag = 0;
1871               if (*s == ',')
1872                 {
1873                   s++;
1874                   name = s;
1875                   while (*s != ',' && *s != ' ' && *s != '\t')
1876                     s += 1;
1877                   c = *s;
1878                   *s = 0x00;
1879                   if (strcmp (name, "=") == 0)
1880                     cmpltr = 1;
1881                   else if (strcmp (name, "<") == 0)
1882                     cmpltr = 2;
1883                   else if (strcmp (name, "<=") == 0)
1884                     cmpltr = 3;
1885                   else if (strcasecmp (name, "od") == 0)
1886                     cmpltr = 7;
1887                   else if (strcasecmp (name, "tr") == 0)
1888                     {
1889                       cmpltr = 0;
1890                       flag = 1;
1891                     }
1892                   else if (strcmp (name, "<>") == 0)
1893                     {
1894                       cmpltr = 1;
1895                       flag = 1;
1896                     }
1897                   else if (strcmp (name, ">=") == 0)
1898                     {
1899                       cmpltr = 2;
1900                       flag = 1;
1901                     }
1902                   else if (strcmp (name, ">") == 0)
1903                     {
1904                       cmpltr = 3;
1905                       flag = 1;
1906                     }
1907                   else if (strcasecmp (name, "ev") == 0)
1908                     {
1909                       cmpltr = 7;
1910                       flag = 1;
1911                     }
1912                   else
1913                     as_bad ("Invalid Logical Instruction Condition.");
1914                   *s = c;
1915                 }
1916               opcode |= cmpltr << 13;
1917               opcode |= flag << 12;
1918               continue;
1919
1920             /* Handle a unit instruction condition.  */
1921             case 'U':
1922               cmpltr = 0;
1923               flag = 0;
1924               if (*s == ',')
1925                 {
1926                   s++;
1927                   if (strncasecmp (s, "sbz", 3) == 0)
1928                     {
1929                       cmpltr = 2;
1930                       s += 3;
1931                     }
1932                   else if (strncasecmp (s, "shz", 3) == 0)
1933                     {
1934                       cmpltr = 3;
1935                       s += 3;
1936                     }
1937                   else if (strncasecmp (s, "sdc", 3) == 0)
1938                     {
1939                       cmpltr = 4;
1940                       s += 3;
1941                     }
1942                   else if (strncasecmp (s, "sbc", 3) == 0)
1943                     {
1944                       cmpltr = 6;
1945                       s += 3;
1946                     }
1947                   else if (strncasecmp (s, "shc", 3) == 0)
1948                     {
1949                       cmpltr = 7;
1950                       s += 3;
1951                     }
1952                   else if (strncasecmp (s, "tr", 2) == 0)
1953                     {
1954                       cmpltr = 0;
1955                       flag = 1;
1956                       s += 2;
1957                     }
1958                   else if (strncasecmp (s, "nbz", 3) == 0)
1959                     {
1960                       cmpltr = 2;
1961                       flag = 1;
1962                       s += 3;
1963                     }
1964                   else if (strncasecmp (s, "nhz", 3) == 0)
1965                     {
1966                       cmpltr = 3;
1967                       flag = 1;
1968                       s += 3;
1969                     }
1970                   else if (strncasecmp (s, "ndc", 3) == 0)
1971                     {
1972                       cmpltr = 4;
1973                       flag = 1;
1974                       s += 3;
1975                     }
1976                   else if (strncasecmp (s, "nbc", 3) == 0)
1977                     {
1978                       cmpltr = 6;
1979                       flag = 1;
1980                       s += 3;
1981                     }
1982                   else if (strncasecmp (s, "nhc", 3) == 0)
1983                     {
1984                       cmpltr = 7;
1985                       flag = 1;
1986                       s += 3;
1987                     }
1988                   else
1989                     as_bad ("Invalid Logical Instruction Condition.");
1990                 }
1991               opcode |= cmpltr << 13;
1992               opcode |= flag << 12;
1993               continue;
1994
1995             /* Handle a shift/extract/deposit condition.  */
1996             case '|':
1997             case '>':
1998               cmpltr = 0;
1999               if (*s == ',')
2000                 {
2001                   save_s = s++;
2002                   name = s;
2003                   while (*s != ',' && *s != ' ' && *s != '\t')
2004                     s += 1;
2005                   c = *s;
2006                   *s = 0x00;
2007                   if (strcmp (name, "=") == 0)
2008                     cmpltr = 1;
2009                   else if (strcmp (name, "<") == 0)
2010                     cmpltr = 2;
2011                   else if (strcasecmp (name, "od") == 0)
2012                     cmpltr = 3;
2013                   else if (strcasecmp (name, "tr") == 0)
2014                     cmpltr = 4;
2015                   else if (strcmp (name, "<>") == 0)
2016                     cmpltr = 5;
2017                   else if (strcmp (name, ">=") == 0)
2018                     cmpltr = 6;
2019                   else if (strcasecmp (name, "ev") == 0)
2020                     cmpltr = 7;
2021                   /* Handle movb,n.  Put things back the way they were.
2022                      This includes moving s back to where it started.  */
2023                   else if (strcasecmp (name, "n") == 0 && *args == '|')
2024                     {
2025                       *s = c;
2026                       s = save_s;
2027                       continue;
2028                     }
2029                   else
2030                     as_bad ("Invalid Shift/Extract/Deposit Condition.");
2031                   *s = c;
2032                 }
2033               opcode |= cmpltr << 13;
2034               continue;
2035
2036             /* Handle bvb and bb conditions.  */
2037             case '~':
2038               cmpltr = 0;
2039               if (*s == ',')
2040                 {
2041                   s++;
2042                   if (strncmp (s, "<", 1) == 0)
2043                     {
2044                       cmpltr = 2;
2045                       s++;
2046                     }
2047                   else if (strncmp (s, ">=", 2) == 0)
2048                     {
2049                       cmpltr = 6;
2050                       s += 2;
2051                     }
2052                   else
2053                     as_bad ("Invalid Bit Branch Condition: %c", *s);
2054                 }
2055               opcode |= cmpltr << 13;
2056               continue;
2057
2058             /* Handle a 5 bit immediate at 31.  */
2059             case 'V':
2060               get_expression (s);
2061               low_sign_unext (evaluate_absolute (the_insn.exp,
2062                                                  the_insn.field_selector),
2063                               5, &im5);
2064               opcode |= im5;
2065               s = expr_end;
2066               continue;
2067
2068             /* Handle an unsigned 5 bit immediate at 31.  */
2069             case 'r':
2070               get_expression (s);
2071               im5 = evaluate_absolute (the_insn.exp, the_insn.field_selector);
2072               if (im5 > 31)
2073                 {
2074                   as_bad ("Operand out of range. Was: %d. Should be [0..31].",
2075                           im5);
2076                   im5 = im5 & 0x1f;
2077                 }
2078               opcode |= im5;
2079               s = expr_end;
2080               continue;
2081
2082             /* Handle an unsigned 5 bit immediate at 15.  */
2083             case 'R':
2084               get_expression (s);
2085               im5 = evaluate_absolute (the_insn.exp, the_insn.field_selector);
2086               if (im5 > 31)
2087                 {
2088                   as_bad ("Operand out of range. Was: %d. Should be [0..31].",
2089                           im5);
2090                   im5 = im5 & 0x1f;
2091                 }
2092               opcode |= im5 << 16;
2093               s = expr_end;
2094               continue;
2095
2096             /* Handle a 11 bit immediate at 31.  */
2097             case 'i':
2098               the_insn.field_selector = pa_chk_field_selector (&s);
2099               get_expression (s);
2100               if (the_insn.exp.X_op == O_constant)
2101                 {
2102                   low_sign_unext (evaluate_absolute (the_insn.exp,
2103                                                      the_insn.field_selector),
2104                                   11, &im11);
2105                   opcode |= im11;
2106                 }
2107               else
2108                 {
2109                   if (is_DP_relative (the_insn.exp))
2110                     the_insn.reloc = R_HPPA_GOTOFF;
2111                   else if (is_PC_relative (the_insn.exp))
2112                     the_insn.reloc = R_HPPA_PCREL_CALL;
2113                   else if (is_complex (the_insn.exp))
2114                     the_insn.reloc = R_HPPA_COMPLEX;
2115                   else
2116                     the_insn.reloc = R_HPPA;
2117                   the_insn.format = 11;
2118                 }
2119               s = expr_end;
2120               continue;
2121
2122             /* Handle a 14 bit immediate at 31.  */
2123             case 'j':
2124               the_insn.field_selector = pa_chk_field_selector (&s);
2125               get_expression (s);
2126               if (the_insn.exp.X_op == O_constant)
2127                 {
2128                   low_sign_unext (evaluate_absolute (the_insn.exp,
2129                                                      the_insn.field_selector),
2130                                   14, &im14);
2131                   if (the_insn.field_selector == e_rsel)
2132                     opcode |= (im14 & 0xfff);
2133                   else
2134                     opcode |= im14;
2135                 }
2136               else
2137                 {
2138                   if (is_DP_relative (the_insn.exp))
2139                     the_insn.reloc = R_HPPA_GOTOFF;
2140                   else if (is_PC_relative (the_insn.exp))
2141                     the_insn.reloc = R_HPPA_PCREL_CALL;
2142                   else if (is_complex (the_insn.exp))
2143                     the_insn.reloc = R_HPPA_COMPLEX;
2144                   else
2145                     the_insn.reloc = R_HPPA;
2146                   the_insn.format = 14;
2147                 }
2148               s = expr_end;
2149               continue;
2150
2151             /* Handle a 21 bit immediate at 31.  */
2152             case 'k':
2153               the_insn.field_selector = pa_chk_field_selector (&s);
2154               get_expression (s);
2155               if (the_insn.exp.X_op == O_constant)
2156                 {
2157                   dis_assemble_21 (evaluate_absolute (the_insn.exp,
2158                                                       the_insn.field_selector),
2159                                    &im21);
2160                   opcode |= im21;
2161                 }
2162               else
2163                 {
2164                   if (is_DP_relative (the_insn.exp))
2165                     the_insn.reloc = R_HPPA_GOTOFF;
2166                   else if (is_PC_relative (the_insn.exp))
2167                     the_insn.reloc = R_HPPA_PCREL_CALL;
2168                   else if (is_complex (the_insn.exp))
2169                     the_insn.reloc = R_HPPA_COMPLEX;
2170                   else
2171                     the_insn.reloc = R_HPPA;
2172                   the_insn.format = 21;
2173                 }
2174               s = expr_end;
2175               continue;
2176
2177             /* Handle a nullification completer for branch instructions.  */
2178             case 'n':
2179               nullif = pa_parse_nullif (&s);
2180               opcode |= nullif << 1;
2181               continue;
2182
2183             /* Handle a 12 bit branch displacement.  */
2184             case 'w':
2185               the_insn.field_selector = pa_chk_field_selector (&s);
2186               get_expression (s);
2187               the_insn.pcrel = 1;
2188               if (!strcmp (S_GET_NAME (the_insn.exp.X_add_symbol), "L0\001"))
2189                 {
2190                   unsigned int w1, w, result;
2191
2192                   sign_unext ((the_insn.exp.X_add_number - 8) >> 2, 12,
2193                               &result);
2194                   dis_assemble_12 (result, &w1, &w);
2195                   opcode |= ((w1 << 2) | w);
2196                 }
2197               else
2198                 {
2199                   if (is_complex (the_insn.exp))
2200                     the_insn.reloc = R_HPPA_COMPLEX_PCREL_CALL;
2201                   else
2202                     the_insn.reloc = R_HPPA_PCREL_CALL;
2203                   the_insn.format = 12;
2204                   the_insn.arg_reloc = last_call_desc.arg_reloc;
2205                   bzero (&last_call_desc, sizeof (struct call_desc));
2206                 }
2207               s = expr_end;
2208               continue;
2209
2210             /* Handle a 17 bit branch displacement.  */
2211             case 'W':
2212               the_insn.field_selector = pa_chk_field_selector (&s);
2213               get_expression (s);
2214               the_insn.pcrel = 1;
2215               if (the_insn.exp.X_add_symbol)
2216                 {
2217                   if (!strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
2218                                "L0\001"))
2219                     {
2220                       unsigned int w2, w1, w, result;
2221
2222                       sign_unext ((the_insn.exp.X_add_number - 8) >> 2, 17,
2223                                   &result);
2224                       dis_assemble_17 (result, &w1, &w2, &w);
2225                       opcode |= ((w2 << 2) | (w1 << 16) | w);
2226                     }
2227                   else
2228                     {
2229                       if (is_complex (the_insn.exp))
2230                         the_insn.reloc = R_HPPA_COMPLEX_PCREL_CALL;
2231                       else
2232                         the_insn.reloc = R_HPPA_PCREL_CALL;
2233                       the_insn.format = 17;
2234                       the_insn.arg_reloc = last_call_desc.arg_reloc;
2235                       bzero (&last_call_desc, sizeof (struct call_desc));
2236                     }
2237                 }
2238               else
2239                 {
2240                   unsigned int w2, w1, w, result;
2241
2242                   sign_unext (the_insn.exp.X_add_number >> 2, 17, &result);
2243                   dis_assemble_17 (result, &w1, &w2, &w);
2244                   opcode |= ((w2 << 2) | (w1 << 16) | w);
2245                 }
2246               s = expr_end;
2247               continue;
2248
2249             /* Handle an absolute 17 bit branch target.  */
2250             case 'z':
2251               the_insn.field_selector = pa_chk_field_selector (&s);
2252               get_expression (s);
2253               the_insn.pcrel = 0;
2254               if (the_insn.exp.X_add_symbol)
2255                 {
2256                   if (!strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
2257                                "L0\001"))
2258                     {
2259                       unsigned int w2, w1, w, result;
2260
2261                       sign_unext ((the_insn.exp.X_add_number - 8) >> 2, 17,
2262                                   &result);
2263                       dis_assemble_17 (result, &w1, &w2, &w);
2264                       opcode |= ((w2 << 2) | (w1 << 16) | w);
2265                     }
2266                   else
2267                     {
2268                       if (is_complex (the_insn.exp))
2269                         the_insn.reloc = R_HPPA_COMPLEX_ABS_CALL;
2270                       else
2271                         the_insn.reloc = R_HPPA_ABS_CALL;
2272                       the_insn.format = 17;
2273                     }
2274                 }
2275               else
2276                 {
2277                   unsigned int w2, w1, w, result;
2278
2279                   sign_unext (the_insn.exp.X_add_number >> 2, 17, &result);
2280                   dis_assemble_17 (result, &w1, &w2, &w);
2281                   opcode |= ((w2 << 2) | (w1 << 16) | w);
2282                 }
2283               s = expr_end;
2284               continue;
2285
2286             /* Handle a 5 bit shift count at 26.  */
2287             case 'p':
2288               get_expression (s);
2289               if (the_insn.exp.X_op == O_constant)
2290                 opcode |= (((31 - the_insn.exp.X_add_number) & 0x1f) << 5);
2291               s = expr_end;
2292               continue;
2293
2294             /* Handle a 5 bit bit position at 26.  */
2295             case 'P':
2296               get_expression (s);
2297               if (the_insn.exp.X_op == O_constant)
2298                 opcode |= (the_insn.exp.X_add_number & 0x1f) << 5;
2299               s = expr_end;
2300               continue;
2301
2302             /* Handle a 5 bit immediate at 10.  */
2303             case 'Q':
2304               get_expression (s);
2305               im5 = evaluate_absolute (the_insn.exp, the_insn.field_selector);
2306               if (im5 > 31)
2307                 {
2308                   as_bad ("Operand out of range. Was: %d. Should be [0..31].",
2309                           im5);
2310                   im5 = im5 & 0x1f;
2311                 }
2312               opcode |= im5 << 21;
2313               s = expr_end;
2314               continue;
2315
2316             /* Handle a 13 bit immediate at 18.  */
2317             case 'A':
2318               pa_get_absolute_expression (s);
2319               if (the_insn.exp.X_op == O_constant)
2320                 opcode |= (the_insn.exp.X_add_number & 0x1fff) << 13;
2321               s = expr_end;
2322               continue;
2323
2324             /* Handle a system control completer.  */
2325             case 'Z':
2326               if (*s == ',' && (*(s + 1) == 'm' || *(s + 1) == 'M'))
2327                 {
2328                   m = 1;
2329                   s += 2;
2330                 }
2331               else
2332                 m = 0;
2333
2334               opcode |= m << 5;
2335               while (*s == ' ' || *s == '\t')
2336                 s++;
2337               continue;
2338
2339             /* Handle a 26 bit immediate at 31.  */
2340             case 'D':
2341               the_insn.field_selector = pa_chk_field_selector (&s);
2342               get_expression (s);
2343               if (the_insn.exp.X_op == O_constant)
2344                 {
2345                   opcode |= ((evaluate_absolute (the_insn.exp,
2346                                                  the_insn.field_selector)
2347                               & 0x1ffffff) << 1);
2348                 }
2349               else
2350                 as_bad ("Invalid DIAG operand");
2351               s = expr_end;
2352               continue;
2353
2354             /* Handle a 3 bit SFU identifier at 25.  */
2355             case 'f':
2356               sfu = pa_parse_number (&s, 0);
2357               if ((sfu > 7) || (sfu < 0))
2358                 as_bad ("Invalid SFU identifier: %02x", sfu);
2359               opcode |= (sfu & 7) << 6;
2360               continue;
2361
2362             /* We don't support any of these.  FIXME.  */
2363             case 'O':
2364               get_expression (s);
2365               s = expr_end;
2366               abort ();
2367               continue;
2368
2369             /* Handle a source FP operand format completer.  */
2370             case 'F':
2371               flag = pa_parse_fp_format (&s);
2372               opcode |= (int) flag << 11;
2373               the_insn.fpof1 = flag;
2374               continue;
2375
2376             /* Handle a destination FP operand format completer.  */
2377             case 'G':
2378
2379               /* pa_parse_format needs the ',' prefix.  */
2380               s--;
2381               flag = pa_parse_fp_format (&s);
2382               opcode |= (int) flag << 13;
2383               the_insn.fpof2 = flag;
2384               continue;
2385
2386             /* Handle FP compare conditions.  */
2387             case 'M':
2388               cond = pa_parse_fp_cmp_cond (&s);
2389               opcode |= cond;
2390               continue;
2391
2392             /* Handle L/R register halves like 't'.  */
2393             case 'v':
2394               {
2395                 struct pa_89_fp_reg_struct result;
2396
2397                 pa_parse_number (&s, &result);
2398                 if (result.number_part < 32 && result.number_part >= 0)
2399                   {
2400                     opcode |= (result.number_part & 0x1f);
2401
2402                     /* 0x30 opcodes are FP arithmetic operation opcodes
2403                        and need to be turned into 0x38 opcodes.  This
2404                        is not necessary for loads/stores.  */
2405                     if (need_89_opcode (&the_insn, &result))
2406                       {
2407                         if ((opcode & 0xfc000000) == 0x30000000)
2408                           {
2409                             opcode |= (result.l_r_select & 1) << 6;
2410                             opcode |= 1 << 27;
2411                           }
2412                         else
2413                           {
2414                             opcode |= (result.l_r_select & 1) << 6;
2415                           }
2416                       }
2417                     continue;
2418                   }
2419               }
2420               break;
2421
2422             /* Handle L/R register halves like 'b'.  */
2423             case 'E':
2424               {
2425                 struct pa_89_fp_reg_struct result;
2426
2427                 pa_parse_number (&s, &result);
2428                 if (result.number_part < 32 && result.number_part >= 0)
2429                   {
2430                     opcode |= (result.number_part & 0x1f) << 21;
2431                     if (need_89_opcode (&the_insn, &result))
2432                       {
2433                         opcode |= (result.l_r_select & 1) << 7;
2434                         opcode |= 1 << 27;
2435                       }
2436                     continue;
2437                   }
2438               }
2439               break;
2440
2441             /* Handle L/R register halves like 'x'.  */
2442             case 'X':
2443               {
2444                 struct pa_89_fp_reg_struct result;
2445
2446                 pa_parse_number (&s, &result);
2447                 if (result.number_part < 32 && result.number_part >= 0)
2448                   {
2449                     opcode |= (result.number_part & 0x1f) << 16;
2450                     if (need_89_opcode (&the_insn, &result))
2451                       {
2452                         opcode |= (result.l_r_select & 1) << 12;
2453                         opcode |= 1 << 27;
2454                       }
2455                     continue;
2456                   }
2457               }
2458               break;
2459
2460             /* Handle a 5 bit register field at 10.  */
2461             case '4':
2462               {
2463                 struct pa_89_fp_reg_struct result;
2464                 int status;
2465
2466                 status = pa_parse_number (&s, &result);
2467                 if (result.number_part < 32 && result.number_part >= 0)
2468                   {
2469                     if (the_insn.fpof1 == SGL)
2470                       {
2471                         result.number_part &= 0xF;
2472                         result.number_part |= (result.l_r_select & 1) << 4;
2473                       }
2474                     opcode |= result.number_part << 21;
2475                     continue;
2476                   }
2477               }
2478               break;
2479
2480             /* Handle a 5 bit register field at 15.  */
2481             case '6':
2482               {
2483                 struct pa_89_fp_reg_struct result;
2484                 int status;
2485
2486                 status = pa_parse_number (&s, &result);
2487                 if (result.number_part < 32 && result.number_part >= 0)
2488                   {
2489                     if (the_insn.fpof1 == SGL)
2490                       {
2491                         result.number_part &= 0xF;
2492                         result.number_part |= (result.l_r_select & 1) << 4;
2493                       }
2494                     opcode |= result.number_part << 16;
2495                     continue;
2496                   }
2497               }
2498               break;
2499
2500             /* Handle a 5 bit register field at 31.  */
2501             case '7':
2502               {
2503                 struct pa_89_fp_reg_struct result;
2504                 int status;
2505
2506                 status = pa_parse_number (&s, &result);
2507                 if (result.number_part < 32 && result.number_part >= 0)
2508                   {
2509                     if (the_insn.fpof1 == SGL)
2510                       {
2511                         result.number_part &= 0xF;
2512                         result.number_part |= (result.l_r_select & 1) << 4;
2513                       }
2514                     opcode |= result.number_part;
2515                     continue;
2516                   }
2517               }
2518               break;
2519
2520             /* Handle a 5 bit register field at 20.  */
2521             case '8':
2522               {
2523                 struct pa_89_fp_reg_struct result;
2524                 int status;
2525
2526                 status = pa_parse_number (&s, &result);
2527                 if (result.number_part < 32 && result.number_part >= 0)
2528                   {
2529                     if (the_insn.fpof1 == SGL)
2530                       {
2531                         result.number_part &= 0xF;
2532                         result.number_part |= (result.l_r_select & 1) << 4;
2533                       }
2534                     opcode |= result.number_part << 11;
2535                     continue;
2536                   }
2537               }
2538               break;
2539
2540             /* Handle a 5 bit register field at 25.  */
2541             case '9':
2542               {
2543                 struct pa_89_fp_reg_struct result;
2544                 int status;
2545
2546                 status = pa_parse_number (&s, &result);
2547                 if (result.number_part < 32 && result.number_part >= 0)
2548                   {
2549                     if (the_insn.fpof1 == SGL)
2550                       {
2551                         result.number_part &= 0xF;
2552                         result.number_part |= (result.l_r_select & 1) << 4;
2553                       }
2554                     opcode |= result.number_part << 6;
2555                     continue;
2556                   }
2557               }
2558               break;
2559
2560             /* Handle a floating point operand format at 26.
2561                Only allows single and double precision.  */
2562             case 'H':
2563               flag = pa_parse_fp_format (&s);
2564               switch (flag)
2565                 {
2566                 case SGL:
2567                   opcode |= 0x20;
2568                 case DBL:
2569                   the_insn.fpof1 = flag;
2570                   continue;
2571
2572                 case QUAD:
2573                 case ILLEGAL_FMT:
2574                 default:
2575                   as_bad ("Invalid Floating Point Operand Format.");
2576                 }
2577               break;
2578
2579             default:
2580               abort ();
2581             }
2582           break;
2583         }
2584
2585       /* Check if the args matched.  */
2586       if (match == FALSE)
2587         {
2588           if (&insn[1] - pa_opcodes < NUMOPCODES
2589               && !strcmp (insn->name, insn[1].name))
2590             {
2591               ++insn;
2592               s = argstart;
2593               continue;
2594             }
2595           else
2596             {
2597               as_bad ("Invalid operands %s", error_message);
2598               return;
2599             }
2600         }
2601       break;
2602     }
2603
2604   the_insn.opcode = opcode;
2605   return;
2606 }
2607
2608 /* Turn a string in input_line_pointer into a floating point constant of type
2609    type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
2610    emitted is stored in *sizeP .  An error message or NULL is returned.  */
2611
2612 #define MAX_LITTLENUMS 6
2613
2614 char *
2615 md_atof (type, litP, sizeP)
2616      char type;
2617      char *litP;
2618      int *sizeP;
2619 {
2620   int prec;
2621   LITTLENUM_TYPE words[MAX_LITTLENUMS];
2622   LITTLENUM_TYPE *wordP;
2623   char *t;
2624
2625   switch (type)
2626     {
2627
2628     case 'f':
2629     case 'F':
2630     case 's':
2631     case 'S':
2632       prec = 2;
2633       break;
2634
2635     case 'd':
2636     case 'D':
2637     case 'r':
2638     case 'R':
2639       prec = 4;
2640       break;
2641
2642     case 'x':
2643     case 'X':
2644       prec = 6;
2645       break;
2646
2647     case 'p':
2648     case 'P':
2649       prec = 6;
2650       break;
2651
2652     default:
2653       *sizeP = 0;
2654       return "Bad call to MD_ATOF()";
2655     }
2656   t = atof_ieee (input_line_pointer, type, words);
2657   if (t)
2658     input_line_pointer = t;
2659   *sizeP = prec * sizeof (LITTLENUM_TYPE);
2660   for (wordP = words; prec--;)
2661     {
2662       md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
2663       litP += sizeof (LITTLENUM_TYPE);
2664     }
2665   return NULL;
2666 }
2667
2668 /* Write out big-endian.  */
2669
2670 void
2671 md_number_to_chars (buf, val, n)
2672      char *buf;
2673      valueT val;
2674      int n;
2675 {
2676
2677   switch (n)
2678     {
2679     case 4:
2680       *buf++ = val >> 24;
2681       *buf++ = val >> 16;
2682     case 2:
2683       *buf++ = val >> 8;
2684     case 1:
2685       *buf = val;
2686       break;
2687     default:
2688       abort ();
2689     }
2690   return;
2691 }
2692
2693 /* Translate internal representation of relocation info to BFD target
2694    format.  */
2695
2696 arelent **
2697 tc_gen_reloc (section, fixp)
2698      asection *section;
2699      fixS *fixp;
2700 {
2701   arelent *reloc;
2702   struct hppa_fix_struct *hppa_fixp = fixp->tc_fix_data;
2703   bfd_reloc_code_real_type code;
2704   static int unwind_reloc_fixp_cnt = 0;
2705   static arelent *unwind_reloc_entryP = NULL;
2706   static arelent *no_relocs = NULL;
2707   arelent **relocs;
2708   bfd_reloc_code_real_type **codes;
2709   int n_relocs;
2710   int i;
2711
2712   if (fixp->fx_addsy == 0)
2713     return &no_relocs;
2714   assert (hppa_fixp != 0);
2715   assert (section != 0);
2716
2717 #ifdef OBJ_ELF
2718   /* Yuk.  I would really like to push all this ELF specific unwind
2719      crud into BFD and the linker.  That's how SOM does it -- and
2720      if we could make ELF emulate that then we could share more code
2721      in GAS (and potentially a gnu-linker later).
2722
2723      Unwind section relocations are handled in a special way.
2724      The relocations for the .unwind section are originally
2725      built in the usual way.  That is, for each unwind table
2726      entry there are two relocations:  one for the beginning of
2727      the function and one for the end.
2728
2729      The first time we enter this function we create a
2730      relocation of the type R_HPPA_UNWIND_ENTRIES.  The addend
2731      of the relocation is initialized to 0.  Each additional
2732      pair of times this function is called for the unwind
2733      section represents an additional unwind table entry.  Thus,
2734      the addend of the relocation should end up to be the number
2735      of unwind table entries.  */
2736   if (strcmp (UNWIND_SECTION_NAME, section->name) == 0)
2737     {
2738       if (unwind_reloc_entryP == NULL)
2739         {
2740           reloc = (arelent *) bfd_alloc_by_size_t (stdoutput,
2741                                                    sizeof (arelent));
2742           assert (reloc != 0);
2743           unwind_reloc_entryP = reloc;
2744           unwind_reloc_fixp_cnt++;
2745           unwind_reloc_entryP->address
2746             = fixp->fx_frag->fr_address + fixp->fx_where;
2747           /* A pointer to any function will do.  We only
2748              need one to tell us what section the unwind
2749              relocations are for. */
2750           unwind_reloc_entryP->sym_ptr_ptr = &fixp->fx_addsy->bsym;
2751           hppa_fixp->fx_r_type = code = R_HPPA_UNWIND_ENTRIES;
2752           fixp->fx_r_type = R_HPPA_UNWIND;
2753           unwind_reloc_entryP->howto = bfd_reloc_type_lookup (stdoutput, code);
2754           unwind_reloc_entryP->addend = unwind_reloc_fixp_cnt / 2;
2755           relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
2756                                                      sizeof (arelent *) * 2);
2757           assert (relocs != 0);
2758           relocs[0] = unwind_reloc_entryP;
2759           relocs[1] = NULL;
2760           return relocs;
2761         }
2762       unwind_reloc_fixp_cnt++;
2763       unwind_reloc_entryP->addend = unwind_reloc_fixp_cnt / 2;
2764
2765       return &no_relocs;
2766     }
2767 #endif
2768
2769   reloc = (arelent *) bfd_alloc_by_size_t (stdoutput, sizeof (arelent));
2770   assert (reloc != 0);
2771
2772   reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
2773   codes = hppa_gen_reloc_type (stdoutput,
2774                                fixp->fx_r_type,
2775                                hppa_fixp->fx_r_format,
2776                                hppa_fixp->fx_r_field);
2777
2778   for (n_relocs = 0; codes[n_relocs]; n_relocs++)
2779     ;
2780
2781   relocs = (arelent **)
2782     bfd_alloc_by_size_t (stdoutput, sizeof (arelent *) * n_relocs + 1);
2783   assert (relocs != 0);
2784
2785   reloc = (arelent *) bfd_alloc_by_size_t (stdoutput,
2786                                            sizeof (arelent) * n_relocs);
2787   if (n_relocs > 0)
2788     assert (reloc != 0);
2789
2790   for (i = 0; i < n_relocs; i++)
2791     relocs[i] = &reloc[i];
2792
2793   relocs[n_relocs] = NULL;
2794
2795 #ifdef OBJ_ELF
2796   switch (fixp->fx_r_type)
2797     {
2798     case R_HPPA_COMPLEX:
2799     case R_HPPA_COMPLEX_PCREL_CALL:
2800     case R_HPPA_COMPLEX_ABS_CALL:
2801       assert (n_relocs == 5);
2802
2803       for (i = 0; i < n_relocs; i++)
2804         {
2805           reloc[i].sym_ptr_ptr = NULL;
2806           reloc[i].address = 0;
2807           reloc[i].addend = 0;
2808           reloc[i].howto = bfd_reloc_type_lookup (stdoutput, *codes[i]);
2809           assert (reloc[i].howto && *codes[i] == reloc[i].howto->type);
2810         }
2811
2812       reloc[0].sym_ptr_ptr = &fixp->fx_addsy->bsym;
2813       reloc[1].sym_ptr_ptr = &fixp->fx_subsy->bsym;
2814       reloc[4].address = fixp->fx_frag->fr_address + fixp->fx_where;
2815
2816       if (fixp->fx_r_type == R_HPPA_COMPLEX)
2817         reloc[3].addend = fixp->fx_addnumber;
2818       else if (fixp->fx_r_type == R_HPPA_COMPLEX_PCREL_CALL ||
2819                fixp->fx_r_type == R_HPPA_COMPLEX_ABS_CALL)
2820         reloc[1].addend = fixp->fx_addnumber;
2821
2822       break;
2823
2824     default:
2825       assert (n_relocs == 1);
2826
2827       code = *codes[0];
2828
2829       reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
2830       reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
2831       reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2832       reloc->addend = 0;        /* default */
2833
2834       assert (reloc->howto && code == reloc->howto->type);
2835
2836       /* Now, do any processing that is dependent on the relocation type.  */
2837       switch (code)
2838         {
2839         case R_HPPA_PLABEL_32:
2840         case R_HPPA_PLABEL_11:
2841         case R_HPPA_PLABEL_14:
2842         case R_HPPA_PLABEL_L21:
2843         case R_HPPA_PLABEL_R11:
2844         case R_HPPA_PLABEL_R14:
2845           /* For plabel relocations, the addend of the
2846              relocation should be either 0 (no static link) or 2
2847              (static link required).
2848
2849              FIXME: assume that fx_addnumber contains this
2850              information */
2851           reloc->addend = fixp->fx_addnumber;
2852           break;
2853
2854         case R_HPPA_ABS_CALL_11:
2855         case R_HPPA_ABS_CALL_14:
2856         case R_HPPA_ABS_CALL_17:
2857         case R_HPPA_ABS_CALL_L21:
2858         case R_HPPA_ABS_CALL_R11:
2859         case R_HPPA_ABS_CALL_R14:
2860         case R_HPPA_ABS_CALL_R17:
2861         case R_HPPA_ABS_CALL_LS21:
2862         case R_HPPA_ABS_CALL_RS11:
2863         case R_HPPA_ABS_CALL_RS14:
2864         case R_HPPA_ABS_CALL_RS17:
2865         case R_HPPA_ABS_CALL_LD21:
2866         case R_HPPA_ABS_CALL_RD11:
2867         case R_HPPA_ABS_CALL_RD14:
2868         case R_HPPA_ABS_CALL_RD17:
2869         case R_HPPA_ABS_CALL_LR21:
2870         case R_HPPA_ABS_CALL_RR14:
2871         case R_HPPA_ABS_CALL_RR17:
2872
2873         case R_HPPA_PCREL_CALL_11:
2874         case R_HPPA_PCREL_CALL_14:
2875         case R_HPPA_PCREL_CALL_17:
2876         case R_HPPA_PCREL_CALL_L21:
2877         case R_HPPA_PCREL_CALL_R11:
2878         case R_HPPA_PCREL_CALL_R14:
2879         case R_HPPA_PCREL_CALL_R17:
2880         case R_HPPA_PCREL_CALL_LS21:
2881         case R_HPPA_PCREL_CALL_RS11:
2882         case R_HPPA_PCREL_CALL_RS14:
2883         case R_HPPA_PCREL_CALL_RS17:
2884         case R_HPPA_PCREL_CALL_LD21:
2885         case R_HPPA_PCREL_CALL_RD11:
2886         case R_HPPA_PCREL_CALL_RD14:
2887         case R_HPPA_PCREL_CALL_RD17:
2888         case R_HPPA_PCREL_CALL_LR21:
2889         case R_HPPA_PCREL_CALL_RR14:
2890         case R_HPPA_PCREL_CALL_RR17:
2891           /* The constant is stored in the instruction.  */
2892           reloc->addend = HPPA_R_ADDEND (hppa_fixp->fx_arg_reloc, 0);
2893           break;
2894         default:
2895           reloc->addend = fixp->fx_addnumber;
2896           break;
2897         }
2898       break;
2899     }
2900 #else /* OBJ_SOM */
2901
2902   /* Preliminary relocation handling for SOM.  Needs to handle
2903      COMPLEX relocations (yes, I've seen them occur) and it will
2904      need to handle R_ENTRY/R_EXIT relocations in the very near future
2905      (for generating unwinds).  */
2906   switch (fixp->fx_r_type)
2907     {
2908     case R_HPPA_COMPLEX:
2909     case R_HPPA_COMPLEX_PCREL_CALL:
2910     case R_HPPA_COMPLEX_ABS_CALL:
2911       abort();
2912       break;
2913     default:
2914       assert (n_relocs == 1);
2915
2916       code = *codes[0];
2917
2918       reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
2919       reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
2920       reloc->address = fixp->fx_frag->fr_address + fixp->fx_where ;
2921       reloc->addend = 0;
2922
2923       switch (code)
2924         {
2925         case R_PCREL_CALL:
2926         case R_ABS_CALL:
2927           reloc->addend = HPPA_R_ADDEND (hppa_fixp->fx_arg_reloc, 0);
2928           break;
2929         default:
2930           reloc->addend = fixp->fx_addnumber;
2931           break;
2932         }
2933       break;
2934     }
2935 #endif
2936
2937   return relocs;
2938 }
2939
2940 /* Process any machine dependent frag types.  */
2941
2942 void
2943 md_convert_frag (abfd, sec, fragP)
2944      register bfd *abfd;
2945      register asection *sec;
2946      register fragS *fragP;
2947 {
2948   unsigned int address;
2949
2950   if (fragP->fr_type == rs_machine_dependent)
2951     {
2952       switch ((int) fragP->fr_subtype)
2953         {
2954         case 0:
2955           fragP->fr_type = rs_fill;
2956           know (fragP->fr_var == 1);
2957           know (fragP->fr_next);
2958           address = fragP->fr_address + fragP->fr_fix;
2959           if (address % fragP->fr_offset)
2960             {
2961               fragP->fr_offset =
2962                 fragP->fr_next->fr_address
2963                 - fragP->fr_address
2964                 - fragP->fr_fix;
2965             }
2966           else
2967             fragP->fr_offset = 0;
2968           break;
2969         }
2970     }
2971 }
2972
2973 /* Round up a section size to the appropriate boundary. */
2974
2975 valueT
2976 md_section_align (segment, size)
2977      asection *segment;
2978      valueT size;
2979 {
2980   int align = bfd_get_section_alignment (stdoutput, segment);
2981   int align2 = (1 << align) - 1;
2982
2983   return (size + align2) & ~align2;
2984
2985 }
2986
2987 /* Create a short jump from FROM_ADDR to TO_ADDR.  Not used on the PA.  */
2988 void
2989 md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
2990      char *ptr;
2991      addressT from_addr, to_addr;
2992      fragS *frag;
2993      symbolS *to_symbol;
2994 {
2995   fprintf (stderr, "pa_create_short_jmp\n");
2996   abort ();
2997 }
2998
2999 /* Create a long jump from FROM_ADDR to TO_ADDR.  Not used on the PA.  */
3000 void
3001 md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
3002      char *ptr;
3003      addressT from_addr, to_addr;
3004      fragS *frag;
3005      symbolS *to_symbol;
3006 {
3007   fprintf (stderr, "pa_create_long_jump\n");
3008   abort ();
3009 }
3010
3011 /* Return the approximate size of a frag before relaxation has occurred.  */
3012 int
3013 md_estimate_size_before_relax (fragP, segment)
3014      register fragS *fragP;
3015      asection *segment;
3016 {
3017   int size;
3018
3019   size = 0;
3020
3021   while ((fragP->fr_fix + size) % fragP->fr_offset)
3022     size++;
3023
3024   return size;
3025 }
3026
3027 /* Parse machine dependent options.  There are none on the PA.  */
3028 int
3029 md_parse_option (argP, cntP, vecP)
3030      char **argP;
3031      int *cntP;
3032      char ***vecP;
3033 {
3034   return 1;
3035 }
3036
3037 /* We have no need to default values of symbols.  */
3038
3039 symbolS *
3040 md_undefined_symbol (name)
3041      char *name;
3042 {
3043   return 0;
3044 }
3045
3046 /* Parse an operand that is machine-specific.
3047    We just return without modifying the expression as we have nothing
3048    to do on the PA.  */
3049
3050 void
3051 md_operand (expressionP)
3052      expressionS *expressionP;
3053 {
3054 }
3055
3056 /* Helper function for md_apply_fix.  Actually determine if the fix
3057    can be applied, and if so, apply it.
3058
3059    If a fix is applied, then set fx_addsy to NULL which indicates
3060    the fix was applied and need not be emitted into the object file.  */
3061
3062 static void
3063 md_apply_fix_1 (fixP, val)
3064      fixS *fixP;
3065      long val;
3066 {
3067   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
3068   struct hppa_fix_struct *hppa_fixP = fixP->tc_fix_data;
3069   long new_val, result;
3070   unsigned int w1, w2, w;
3071
3072   /* There should have been an HPPA specific fixup associated
3073      with the GAS fixup.  */
3074   if (hppa_fixP)
3075     {
3076       unsigned long buf_wd = bfd_get_32 (stdoutput, buf);
3077       unsigned char fmt = bfd_hppa_insn2fmt (buf_wd);
3078
3079       /* Sanity check the fixup type.  */
3080       /* Is this really necessary?  */
3081       if (fixP->fx_r_type == R_HPPA_NONE)
3082         fmt = 0;
3083
3084       /* Remember this value for emit_reloc.  FIXME, is this braindamage
3085          documented anywhere!?!  */
3086       fixP->fx_addnumber = val;
3087
3088       /* Check if this is an undefined symbol.  No relocation can
3089          possibly be performed in this case.  */
3090       if ((fixP->fx_addsy && fixP->fx_addsy->bsym->section == &bfd_und_section)
3091           || (fixP->fx_subsy
3092               && fixP->fx_subsy->bsym->section == &bfd_und_section))
3093         return;
3094
3095       switch (fmt)
3096         {
3097         /* Handle all opcodes with the 'j' operand type.  */
3098         case 14:
3099           new_val = hppa_field_adjust (val, 0, hppa_fixP->fx_r_field);
3100
3101           /* Mask off 14 bits to be changed.  */
3102           bfd_put_32 (stdoutput,
3103                       bfd_get_32 (stdoutput, buf) & 0xffffc000,
3104                       buf);
3105           low_sign_unext (new_val, 14, &result);
3106           break;
3107
3108         /* Handle all opcodes with the 'k' operand type.  */
3109         case 21:
3110           new_val = hppa_field_adjust (val, 0, hppa_fixP->fx_r_field);
3111
3112           /* Mask off 21 bits to be changed.  */
3113           bfd_put_32 (stdoutput,
3114                       bfd_get_32 (stdoutput, buf) & 0xffe00000,
3115                       buf);
3116           dis_assemble_21 (new_val, &result);
3117           break;
3118
3119         /* Handle all the opcodes with the 'i' operand type.  */
3120         case 11:
3121           new_val = hppa_field_adjust (val, 0, hppa_fixP->fx_r_field);
3122
3123           /* Mask off 11 bits to be changed.  */
3124           bfd_put_32 (stdoutput,
3125                       bfd_get_32 (stdoutput, buf) & 0xffff800,
3126                       buf);
3127           low_sign_unext (new_val, 11, &result);
3128           break;
3129
3130         /* Handle all the opcodes with the 'w' operand type.  */
3131         case 12:
3132           new_val = hppa_field_adjust (val, 0, hppa_fixP->fx_r_field);
3133
3134           /* Mask off 11 bits to be changed.  */
3135           sign_unext ((new_val - 8) >> 2, 12, &result);
3136           bfd_put_32 (stdoutput,
3137                       bfd_get_32 (stdoutput, buf) & 0xffffe002,
3138                       buf);
3139
3140           dis_assemble_12 (result, &w1, &w);
3141           result = ((w1 << 2) | w);
3142           fixP->fx_addsy = NULL;
3143           break;
3144
3145 #define too_far(VAL, NUM_BITS) \
3146   (((int)(VAL) > (1 << (NUM_BITS)) - 1) || ((int)(VAL) < (-1 << (NUM_BITS))))
3147
3148 #define stub_needed(CALLER, CALLEE) \
3149   ((CALLEE) && (CALLER) && ((CALLEE) != (CALLER)))
3150
3151         /* Handle some of the opcodes with the 'W' operand type.  */
3152         case 17:
3153           /* If a long-call stub or argument relocation stub is
3154              needed, then we can not apply this relocation, instead
3155              the linker must handle it.  */
3156           if (too_far (val, 18)
3157               || stub_needed (((obj_symbol_type *)
3158                                fixP->fx_addsy->bsym)->tc_data.hppa_arg_reloc,
3159                               hppa_fixP->fx_arg_reloc))
3160             return;
3161
3162           /* No stubs were needed, we can perform this relocation.  */
3163           new_val = hppa_field_adjust (val, 0, hppa_fixP->fx_r_field);
3164
3165           /* Mask off 17 bits to be changed.  */
3166           bfd_put_32 (stdoutput,
3167                       bfd_get_32 (stdoutput, buf) & 0xffe0e002,
3168                       buf);
3169           sign_unext ((new_val - 8) >> 2, 17, &result);
3170           dis_assemble_17 (result, &w1, &w2, &w);
3171           result = ((w2 << 2) | (w1 << 16) | w);
3172           fixP->fx_addsy = NULL;
3173           break;
3174
3175 #undef too_far
3176 #undef stub_needed
3177
3178         case 32:
3179 #ifdef OBJ_ELF
3180           if (hppa_fixP->fx_r_type == R_HPPA_UNWIND_ENTRY
3181               || hppa_fixP->fx_r_type == R_HPPA_UNWIND_ENTRIES)
3182             result = fixP->fx_addnumber;
3183           else
3184 #endif
3185             {
3186               result = 0;
3187               fixP->fx_addnumber = fixP->fx_offset;
3188               bfd_put_32 (stdoutput, 0, buf);
3189               return;
3190             }
3191           break;
3192
3193         case 0:
3194           return;
3195
3196         default:
3197           as_bad ("bad relocation type/fmt: 0x%02x/0x%02x",
3198                   fixP->fx_r_type, fmt);
3199           return;
3200         }
3201
3202       /* Insert the relocation.  */
3203       buf[0] |= (result & 0xff000000) >> 24;
3204       buf[1] |= (result & 0x00ff0000) >> 16;
3205       buf[2] |= (result & 0x0000ff00) >> 8;
3206       buf[3] |= result & 0x000000ff;
3207     }
3208   else
3209     printf ("no hppa_fixup entry for this fixup (fixP = 0x%x, type = 0x%x)\n",
3210             (unsigned int) fixP, fixP->fx_r_type);
3211 }
3212
3213 /* Apply a fix into a frag's data (if possible).  */
3214
3215 int
3216 md_apply_fix (fixP, valp)
3217      fixS *fixP;
3218      valueT *valp;
3219 {
3220   md_apply_fix_1 (fixP, (long) *valp);
3221   return 1;
3222 }
3223
3224 /* Exactly what point is a PC-relative offset relative TO?
3225    On the PA, they're relative to the address of the offset.  */
3226
3227 long
3228 md_pcrel_from (fixP)
3229      fixS *fixP;
3230 {
3231   return fixP->fx_where + fixP->fx_frag->fr_address;
3232 }
3233
3234 /* Return nonzero if the input line pointer is at the end of
3235    a statement.  */
3236
3237 static int
3238 is_end_of_statement ()
3239 {
3240   return ((*input_line_pointer == '\n')
3241           || (*input_line_pointer == ';')
3242           || (*input_line_pointer == '!'));
3243 }
3244
3245 /* Read a number from S.  The number might come in one of many forms,
3246    the most common will be a hex or decimal constant, but it could be
3247    a pre-defined register (Yuk!), or an absolute symbol.
3248
3249    Return a number or -1 for failure.
3250
3251    When parsing PA-89 FP register numbers RESULT will be
3252    the address of a structure to return information about
3253    L/R half of FP registers, store results there as appropriate.
3254
3255    pa_parse_number can not handle negative constants and will fail
3256    horribly if it is passed such a constant.  */
3257
3258 static int
3259 pa_parse_number (s, result)
3260      char **s;
3261      struct pa_89_fp_reg_struct *result;
3262 {
3263   int num;
3264   char *name;
3265   char c;
3266   symbolS *sym;
3267   int status;
3268   char *p = *s;
3269
3270   /* Skip whitespace before the number.  */
3271   while (*p == ' ' || *p == '\t')
3272     p = p + 1;
3273
3274   /* Store info in RESULT if requested by caller.  */
3275   if (result)
3276     {
3277       result->number_part = -1;
3278       result->l_r_select = -1;
3279     }
3280   num = -1;
3281
3282   if (isdigit (*p))
3283     {
3284       /* Looks like a number.  */
3285       num = 0;
3286
3287       if (*p == '0' && (*(p + 1) == 'x' || *(p + 1) == 'X'))
3288         {
3289           /* The number is specified in hex.  */
3290           p += 2;
3291           while (isdigit (*p) || ((*p >= 'a') && (*p <= 'f'))
3292                  || ((*p >= 'A') && (*p <= 'F')))
3293             {
3294               if (isdigit (*p))
3295                 num = num * 16 + *p - '0';
3296               else if (*p >= 'a' && *p <= 'f')
3297                 num = num * 16 + *p - 'a' + 10;
3298               else
3299                 num = num * 16 + *p - 'A' + 10;
3300               ++p;
3301             }
3302         }
3303       else
3304         {
3305           /* The number is specified in decimal.  */
3306           while (isdigit (*p))
3307             {
3308               num = num * 10 + *p - '0';
3309               ++p;
3310             }
3311         }
3312
3313       /* Store info in RESULT if requested by the caller.  */
3314       if (result)
3315         {
3316           result->number_part = num;
3317
3318           if (IS_R_SELECT (p))
3319             {
3320               result->l_r_select = 1;
3321               ++p;
3322             }
3323           else if (IS_L_SELECT (p))
3324             {
3325               result->l_r_select = 0;
3326               ++p;
3327             }
3328           else
3329             result->l_r_select = 0;
3330         }
3331     }
3332   else if (*p == '%')
3333     {
3334       /* The number might be a predefined register.  */
3335       num = 0;
3336       name = p;
3337       p++;
3338       c = *p;
3339       /* Tege hack: Special case for general registers as the general
3340          code makes a binary search with case translation, and is VERY
3341          slow. */
3342       if (c == 'r')
3343         {
3344           p++;
3345           if (*p == 'e' && *(p + 1) == 't'
3346               && (*(p + 2) == '0' || *(p + 2) == '1'))
3347             {
3348               p += 2;
3349               num = *p - '0' + 28;
3350               p++;
3351             }
3352           else if (!isdigit (*p))
3353             as_bad ("Undefined register: '%s'. ASSUMING 0", name);
3354           else
3355             {
3356               do
3357                 num = num * 10 + *p++ - '0';
3358               while (isdigit (*p));
3359             }
3360         }
3361       else
3362         {
3363           /* Do a normal register search.  */
3364           while (is_part_of_name (c))
3365             {
3366               p = p + 1;
3367               c = *p;
3368             }
3369           *p = 0;
3370           status = reg_name_search (name);
3371           if (status >= 0)
3372             num = status;
3373           else
3374             {
3375               if (print_errors)
3376                 as_bad ("Undefined register: '%s'. ASSUMING 0", name);
3377               else
3378                 num = -1;
3379             }
3380           *p = c;
3381         }
3382
3383       /* Store info in RESULT if requested by caller.  */
3384       if (result)
3385         {
3386           result->number_part = num;
3387           if (IS_R_SELECT (p - 1))
3388             result->l_r_select = 1;
3389           else if (IS_L_SELECT (p - 1))
3390             result->l_r_select = 0;
3391           else
3392             result->l_r_select = 0;
3393         }
3394     }
3395   else
3396     {
3397       /* And finally, it could be a symbol in the absolute section which
3398          is effectively a constant.  */
3399       num = 0;
3400       name = p;
3401       c = *p;
3402       while (is_part_of_name (c))
3403         {
3404           p = p + 1;
3405           c = *p;
3406         }
3407       *p = 0;
3408       if ((sym = symbol_find (name)) != NULL)
3409         {
3410           if (S_GET_SEGMENT (sym) == &bfd_abs_section)
3411             num = S_GET_VALUE (sym);
3412           else
3413             {
3414               if (print_errors)
3415                 as_bad ("Non-absolute constant: '%s'. ASSUMING 0", name);
3416               else
3417                 num = -1;
3418             }
3419         }
3420       else
3421         {
3422           if (print_errors)
3423             as_bad ("Undefined absolute constant: '%s'. ASSUMING 0", name);
3424           else
3425             num = -1;
3426         }
3427       *p = c;
3428
3429       /* Store info in RESULT if requested by caller.  */
3430       if (result)
3431         {
3432           result->number_part = num;
3433           if (IS_R_SELECT (p - 1))
3434             result->l_r_select = 1;
3435           else if (IS_L_SELECT (p - 1))
3436             result->l_r_select = 0;
3437           else
3438             result->l_r_select = 0;
3439         }
3440     }
3441
3442   *s = p;
3443   return num;
3444 }
3445
3446 #define REG_NAME_CNT    (sizeof(pre_defined_registers) / sizeof(struct pd_reg))
3447
3448 /* Given NAME, find the register number associated with that name, return
3449    the integer value associated with the given name or -1 on failure.  */
3450
3451 static int
3452 reg_name_search (name)
3453      char *name;
3454 {
3455   int middle, low, high;
3456
3457   low = 0;
3458   high = REG_NAME_CNT - 1;
3459
3460   do
3461     {
3462       middle = (low + high) / 2;
3463       if (strcasecmp (name, pre_defined_registers[middle].name) < 0)
3464         high = middle - 1;
3465       else
3466         low = middle + 1;
3467     }
3468   while (!((strcasecmp (name, pre_defined_registers[middle].name) == 0) ||
3469            (low > high)));
3470
3471   if (strcasecmp (name, pre_defined_registers[middle].name) == 0)
3472     return (pre_defined_registers[middle].value);
3473   else
3474     return (-1);
3475 }
3476
3477
3478 /* Return nonzero if the given INSN and L/R information will require
3479    a new PA-89 opcode.  */
3480
3481 static int
3482 need_89_opcode (insn, result)
3483      struct pa_it *insn;
3484      struct pa_89_fp_reg_struct *result;
3485 {
3486   if (result->l_r_select == 1 && !(insn->fpof1 == DBL && insn->fpof2 == DBL))
3487     return TRUE;
3488   else
3489     return FALSE;
3490 }
3491
3492 /* Parse a condition for a fcmp instruction.  Return the numerical
3493    code associated with the condition.  */
3494
3495 static int
3496 pa_parse_fp_cmp_cond (s)
3497      char **s;
3498 {
3499   int cond, i;
3500
3501   cond = 0;
3502
3503   for (i = 0; i < 32; i++)
3504     {
3505       if (strncasecmp (*s, fp_cond_map[i].string,
3506                        strlen (fp_cond_map[i].string)) == 0)
3507         {
3508           cond = fp_cond_map[i].cond;
3509           *s += strlen (fp_cond_map[i].string);
3510           while (**s == ' ' || **s == '\t')
3511             *s = *s + 1;
3512           return cond;
3513         }
3514     }
3515
3516   as_bad ("Invalid FP Compare Condition: %c", **s);
3517   return 0;
3518 }
3519
3520 /* Parse an FP operand format completer returning the completer
3521    type.  */
3522
3523 static fp_operand_format
3524 pa_parse_fp_format (s)
3525      char **s;
3526 {
3527   int format;
3528
3529   format = SGL;
3530   if (**s == ',')
3531     {
3532       *s += 1;
3533       if (strncasecmp (*s, "sgl", 3) == 0)
3534         {
3535           format = SGL;
3536           *s += 4;
3537         }
3538       else if (strncasecmp (*s, "dbl", 3) == 0)
3539         {
3540           format = DBL;
3541           *s += 4;
3542         }
3543       else if (strncasecmp (*s, "quad", 4) == 0)
3544         {
3545           format = QUAD;
3546           *s += 5;
3547         }
3548       else
3549         {
3550           format = ILLEGAL_FMT;
3551           as_bad ("Invalid FP Operand Format: %3s", *s);
3552         }
3553     }
3554   while (**s == ' ' || **s == '\t' || **s == 0)
3555     *s = *s + 1;
3556
3557   return format;
3558 }
3559
3560 /* Convert from a selector string into a selector type.  */
3561
3562 static int
3563 pa_chk_field_selector (str)
3564      char **str;
3565 {
3566   int selector;
3567   struct selector_entry *tablep;
3568
3569   selector = e_fsel;
3570
3571   /* Read past any whitespace.  */
3572   while (**str == ' ' || **str == '\t' || **str == '\n' || **str == '\f')
3573     *str = *str + 1;
3574
3575   /* Yuk.  Looks like a linear search through the table.  With the
3576      frequence of some selectors it might make sense to sort the
3577      table by usage.  */
3578   for (tablep = selector_table; tablep->prefix; tablep++)
3579     {
3580       if (strncasecmp (tablep->prefix, *str, strlen (tablep->prefix)) == 0)
3581         {
3582           *str += strlen (tablep->prefix);
3583           selector = tablep->field_selector;
3584           break;
3585         }
3586     }
3587   return selector;
3588 }
3589
3590 /* Mark (via expr_end) the end of an expression (I think).  FIXME.  */
3591
3592 static int
3593 get_expression (str)
3594      char *str;
3595 {
3596   char *save_in;
3597   asection *seg;
3598
3599   save_in = input_line_pointer;
3600   input_line_pointer = str;
3601   seg = expression (&the_insn.exp);
3602   if (!(seg == absolute_section
3603         || seg == undefined_section
3604         || SEG_NORMAL (seg)))
3605     {
3606       as_warn ("Bad segment in expression.");
3607       expr_end = input_line_pointer;
3608       input_line_pointer = save_in;
3609       return 1;
3610     }
3611   expr_end = input_line_pointer;
3612   input_line_pointer = save_in;
3613   return 0;
3614 }
3615
3616 /* Mark (via expr_end) the end of an absolute expression.  FIXME. */
3617 static int
3618 pa_get_absolute_expression (str)
3619      char *str;
3620 {
3621   char *save_in;
3622
3623   save_in = input_line_pointer;
3624   input_line_pointer = str;
3625   expression (&the_insn.exp);
3626   if (the_insn.exp.X_op != O_constant)
3627     {
3628       as_warn ("Bad segment (should be absolute).");
3629       expr_end = input_line_pointer;
3630       input_line_pointer = save_in;
3631       return 1;
3632     }
3633   expr_end = input_line_pointer;
3634   input_line_pointer = save_in;
3635   return 0;
3636 }
3637
3638 /* Evaluate an absolute expression EXP which may be modified by
3639    the selector FIELD_SELECTOR.  Return the value of the expression.  */
3640 static int
3641 evaluate_absolute (exp, field_selector)
3642      expressionS exp;
3643      int field_selector;
3644 {
3645   int value;
3646
3647   value = exp.X_add_number;
3648
3649   switch (field_selector)
3650     {
3651     /* No change.  */
3652     case e_fsel:
3653       break;
3654
3655     /* If bit 21 is on then add 0x800 and arithmetic shift right 11 bits.  */
3656     case e_lssel:
3657       if (value & 0x00000400)
3658         value += 0x800;
3659       value = (value & 0xfffff800) >> 11;
3660       break;
3661
3662     /* Sign extend from bit 21.  */
3663     case e_rssel:
3664       if (value & 0x00000400)
3665         value |= 0xfffff800;
3666       else
3667         value &= 0x7ff;
3668       break;
3669
3670     /* Arithmetic shift right 11 bits.  */
3671     case e_lsel:
3672       value = (value & 0xfffff800) >> 11;
3673       break;
3674
3675     /* Set bits 0-20 to zero.  */
3676     case e_rsel:
3677       value = value & 0x7ff;
3678       break;
3679
3680     /* Add 0x800 and arithmetic shift right 11 bits.  */
3681     case e_ldsel:
3682       value += 0x800;
3683
3684
3685       value = (value & 0xfffff800) >> 11;
3686       break;
3687
3688     /* Set bitgs 0-21 to one.  */
3689     case e_rdsel:
3690       value |= 0xfffff800;
3691       break;
3692
3693     /* This had better get fixed.  It looks like we're quickly moving
3694        to LR/RR.  FIXME.  */
3695     case e_rrsel:
3696     case e_lrsel:
3697       abort ();
3698
3699     default:
3700       BAD_CASE (field_selector);
3701       break;
3702     }
3703   return value;
3704 }
3705
3706 /* Given an argument location specification return the associated
3707    argument location number.  */
3708
3709 static unsigned int
3710 pa_build_arg_reloc (type_name)
3711      char *type_name;
3712 {
3713
3714   if (strncasecmp (type_name, "no", 2) == 0)
3715     return 0;
3716   if (strncasecmp (type_name, "gr", 2) == 0)
3717     return 1;
3718   else if (strncasecmp (type_name, "fr", 2) == 0)
3719     return 2;
3720   else if (strncasecmp (type_name, "fu", 2) == 0)
3721     return 3;
3722   else
3723     as_bad ("Invalid argument location: %s\n", type_name);
3724
3725   return 0;
3726 }
3727
3728 /* Encode and return an argument relocation specification for
3729    the given register in the location specified by arg_reloc.  */
3730
3731 static unsigned int
3732 pa_align_arg_reloc (reg, arg_reloc)
3733      unsigned int reg;
3734      unsigned int arg_reloc;
3735 {
3736   unsigned int new_reloc;
3737
3738   new_reloc = arg_reloc;
3739   switch (reg)
3740     {
3741     case 0:
3742       new_reloc <<= 8;
3743       break;
3744     case 1:
3745       new_reloc <<= 6;
3746       break;
3747     case 2:
3748       new_reloc <<= 4;
3749       break;
3750     case 3:
3751       new_reloc <<= 2;
3752       break;
3753     default:
3754       as_bad ("Invalid argument description: %d", reg);
3755     }
3756
3757   return new_reloc;
3758 }
3759
3760 /* Parse a PA nullification completer (,n).  Return nonzero if the
3761    completer was found; return zero if no completer was found.  */
3762
3763 static int
3764 pa_parse_nullif (s)
3765      char **s;
3766 {
3767   int nullif;
3768
3769   nullif = 0;
3770   if (**s == ',')
3771     {
3772       *s = *s + 1;
3773       if (strncasecmp (*s, "n", 1) == 0)
3774         nullif = 1;
3775       else
3776         {
3777           as_bad ("Invalid Nullification: (%c)", **s);
3778           nullif = 0;
3779         }
3780       *s = *s + 1;
3781     }
3782   while (**s == ' ' || **s == '\t')
3783     *s = *s + 1;
3784
3785   return nullif;
3786 }
3787
3788 /* Parse a non-negated compare/subtract completer returning the
3789    number (for encoding in instrutions) of the given completer.
3790
3791    ISBRANCH specifies whether or not this is parsing a condition
3792    completer for a branch (vs a nullification completer for a
3793    computational instruction.  */
3794
3795 static int
3796 pa_parse_nonneg_cmpsub_cmpltr (s, isbranch)
3797      char **s;
3798      int isbranch;
3799 {
3800   int cmpltr;
3801   char *name = *s + 1;
3802   char c;
3803   char *save_s = *s;
3804
3805   cmpltr = 0;
3806   if (**s == ',')
3807     {
3808       *s += 1;
3809       while (**s != ',' && **s != ' ' && **s != '\t')
3810         *s += 1;
3811       c = **s;
3812       **s = 0x00;
3813       if (strcmp (name, "=") == 0)
3814         {
3815           cmpltr = 1;
3816         }
3817       else if (strcmp (name, "<") == 0)
3818         {
3819           cmpltr = 2;
3820         }
3821       else if (strcmp (name, "<=") == 0)
3822         {
3823           cmpltr = 3;
3824         }
3825       else if (strcmp (name, "<<") == 0)
3826         {
3827           cmpltr = 4;
3828         }
3829       else if (strcmp (name, "<<=") == 0)
3830         {
3831           cmpltr = 5;
3832         }
3833       else if (strcasecmp (name, "sv") == 0)
3834         {
3835           cmpltr = 6;
3836         }
3837       else if (strcasecmp (name, "od") == 0)
3838         {
3839           cmpltr = 7;
3840         }
3841       /* If we have something like addb,n then there is no condition
3842          completer.  */
3843       else if (strcasecmp (name, "n") == 0 && isbranch)
3844         {
3845           cmpltr = 0;
3846         }
3847       else
3848         {
3849           cmpltr = -1;
3850         }
3851       **s = c;
3852     }
3853   if (cmpltr >= 0)
3854     {
3855       while (**s == ' ' || **s == '\t')
3856         *s = *s + 1;
3857     }
3858
3859   /* Reset pointers if this was really a ,n for a branch instruction.  */
3860   if (cmpltr == 0 && *name == 'n' && isbranch)
3861     *s = save_s;
3862
3863   return cmpltr;
3864 }
3865
3866 /* Parse a negated compare/subtract completer returning the
3867    number (for encoding in instrutions) of the given completer.
3868
3869    ISBRANCH specifies whether or not this is parsing a condition
3870    completer for a branch (vs a nullification completer for a
3871    computational instruction.  */
3872
3873 static int
3874 pa_parse_neg_cmpsub_cmpltr (s, isbranch)
3875      char **s;
3876      int isbranch;
3877 {
3878   int cmpltr;
3879   char *name = *s + 1;
3880   char c;
3881   char *save_s = *s;
3882
3883   cmpltr = 0;
3884   if (**s == ',')
3885     {
3886       *s += 1;
3887       while (**s != ',' && **s != ' ' && **s != '\t')
3888         *s += 1;
3889       c = **s;
3890       **s = 0x00;
3891       if (strcasecmp (name, "tr") == 0)
3892         {
3893           cmpltr = 0;
3894         }
3895       else if (strcmp (name, "<>") == 0)
3896         {
3897           cmpltr = 1;
3898         }
3899       else if (strcmp (name, ">=") == 0)
3900         {
3901           cmpltr = 2;
3902         }
3903       else if (strcmp (name, ">") == 0)
3904         {
3905           cmpltr = 3;
3906         }
3907       else if (strcmp (name, ">>=") == 0)
3908         {
3909           cmpltr = 4;
3910         }
3911       else if (strcmp (name, ">>") == 0)
3912         {
3913           cmpltr = 5;
3914         }
3915       else if (strcasecmp (name, "nsv") == 0)
3916         {
3917           cmpltr = 6;
3918         }
3919       else if (strcasecmp (name, "ev") == 0)
3920         {
3921           cmpltr = 7;
3922         }
3923       /* If we have something like addb,n then there is no condition
3924          completer.  */
3925       else if (strcasecmp (name, "n") == 0 && isbranch)
3926         {
3927           cmpltr = 0;
3928         }
3929       else
3930         {
3931           cmpltr = -1;
3932         }
3933       **s = c;
3934     }
3935   if (cmpltr >= 0)
3936     {
3937       while (**s == ' ' || **s == '\t')
3938         *s = *s + 1;
3939     }
3940
3941   /* Reset pointers if this was really a ,n for a branch instruction.  */
3942   if (cmpltr == 0 && *name == 'n' && isbranch)
3943     *s = save_s;
3944
3945   return cmpltr;
3946 }
3947
3948 /* Parse a non-negated addition completer returning the number
3949    (for encoding in instrutions) of the given completer.
3950
3951    ISBRANCH specifies whether or not this is parsing a condition
3952    completer for a branch (vs a nullification completer for a
3953    computational instruction.  */
3954
3955 static int
3956 pa_parse_nonneg_add_cmpltr (s, isbranch)
3957      char **s;
3958      int isbranch;
3959 {
3960   int cmpltr;
3961   char *name = *s + 1;
3962   char c;
3963   char *save_s = *s;
3964
3965   cmpltr = 0;
3966   if (**s == ',')
3967     {
3968       *s += 1;
3969       while (**s != ',' && **s != ' ' && **s != '\t')
3970         *s += 1;
3971       c = **s;
3972       **s = 0x00;
3973       if (strcmp (name, "=") == 0)
3974         {
3975           cmpltr = 1;
3976         }
3977       else if (strcmp (name, "<") == 0)
3978         {
3979           cmpltr = 2;
3980         }
3981       else if (strcmp (name, "<=") == 0)
3982         {
3983           cmpltr = 3;
3984         }
3985       else if (strcasecmp (name, "nuv") == 0)
3986         {
3987           cmpltr = 4;
3988         }
3989       else if (strcasecmp (name, "znv") == 0)
3990         {
3991           cmpltr = 5;
3992         }
3993       else if (strcasecmp (name, "sv") == 0)
3994         {
3995           cmpltr = 6;
3996         }
3997       else if (strcasecmp (name, "od") == 0)
3998         {
3999           cmpltr = 7;
4000         }
4001       /* If we have something like addb,n then there is no condition
4002          completer.  */
4003       else if (strcasecmp (name, "n") == 0 && isbranch)
4004         {
4005           cmpltr = 0;
4006         }
4007       else
4008         {
4009           cmpltr = -1;
4010         }
4011       **s = c;
4012     }
4013   if (cmpltr >= 0)
4014     {
4015       while (**s == ' ' || **s == '\t')
4016         *s = *s + 1;
4017     }
4018
4019   /* Reset pointers if this was really a ,n for a branch instruction.  */
4020   if (cmpltr == 0 && *name == 'n' && isbranch)
4021     *s = save_s;
4022
4023   return cmpltr;
4024 }
4025
4026 /* Parse a negated addition completer returning the number
4027    (for encoding in instrutions) of the given completer.
4028
4029    ISBRANCH specifies whether or not this is parsing a condition
4030    completer for a branch (vs a nullification completer for a
4031    computational instruction.  */
4032
4033 static int
4034 pa_parse_neg_add_cmpltr (s, isbranch)
4035      char **s;
4036      int isbranch;
4037 {
4038   int cmpltr;
4039   char *name = *s + 1;
4040   char c;
4041   char *save_s = *s;
4042
4043   cmpltr = 0;
4044   if (**s == ',')
4045     {
4046       *s += 1;
4047       while (**s != ',' && **s != ' ' && **s != '\t')
4048         *s += 1;
4049       c = **s;
4050       **s = 0x00;
4051       if (strcasecmp (name, "tr") == 0)
4052         {
4053           cmpltr = 0;
4054         }
4055       else if (strcmp (name, "<>") == 0)
4056         {
4057           cmpltr = 1;
4058         }
4059       else if (strcmp (name, ">=") == 0)
4060         {
4061           cmpltr = 2;
4062         }
4063       else if (strcmp (name, ">") == 0)
4064         {
4065           cmpltr = 3;
4066         }
4067       else if (strcmp (name, "uv") == 0)
4068         {
4069           cmpltr = 4;
4070         }
4071       else if (strcmp (name, "vnz") == 0)
4072         {
4073           cmpltr = 5;
4074         }
4075       else if (strcasecmp (name, "nsv") == 0)
4076         {
4077           cmpltr = 6;
4078         }
4079       else if (strcasecmp (name, "ev") == 0)
4080         {
4081           cmpltr = 7;
4082         }
4083       /* If we have something like addb,n then there is no condition
4084          completer.  */
4085       else if (strcasecmp (name, "n") == 0 && isbranch)
4086         {
4087           cmpltr = 0;
4088         }
4089       else
4090         {
4091           cmpltr = -1;
4092         }
4093       **s = c;
4094     }
4095   if (cmpltr >= 0)
4096     {
4097       while (**s == ' ' || **s == '\t')
4098         *s = *s + 1;
4099     }
4100
4101   /* Reset pointers if this was really a ,n for a branch instruction.  */
4102   if (cmpltr == 0 && *name == 'n' && isbranch)
4103     *s = save_s;
4104
4105   return cmpltr;
4106 }
4107
4108 /* Handle a .BLOCK type pseudo-op.  */
4109
4110 static void
4111 pa_block (z)
4112      int z;
4113 {
4114   char *p;
4115   long int temp_fill;
4116   unsigned int temp_size;
4117   int i;
4118
4119   temp_size = get_absolute_expression ();
4120
4121   /* Always fill with zeros, that's what the HP assembler does.  */
4122   temp_fill = 0;
4123
4124   p = frag_var (rs_fill, (int) temp_size, (int) temp_size,
4125                 (relax_substateT) 0, (symbolS *) 0, 1, NULL);
4126   bzero (p, temp_size);
4127
4128   /* Convert 2 bytes at a time.  */
4129
4130   for (i = 0; i < temp_size; i += 2)
4131     {
4132       md_number_to_chars (p + i,
4133                           (valueT) temp_fill,
4134                           (int) ((temp_size - i) > 2 ? 2 : (temp_size - i)));
4135     }
4136
4137   pa_undefine_label ();
4138   demand_empty_rest_of_line ();
4139   return;
4140 }
4141
4142 /* Handle a .CALL pseudo-op.  This involves storing away information
4143    about where arguments are to be found so the linker can detect
4144    (and correct) argument location mismatches between caller and callee.  */
4145
4146 static void
4147 pa_call (unused)
4148      int unused;
4149 {
4150   pa_call_args (&last_call_desc);
4151   demand_empty_rest_of_line ();
4152   return;
4153 }
4154
4155 /* Do the dirty work of building a call descriptor which describes
4156    where the caller placed arguments to a function call.  */
4157
4158 static void
4159 pa_call_args (call_desc)
4160      struct call_desc *call_desc;
4161 {
4162   char *name, c, *p;
4163   unsigned int temp, arg_reloc;
4164
4165   while (!is_end_of_statement ())
4166     {
4167       name = input_line_pointer;
4168       c = get_symbol_end ();
4169       /* Process a source argument.  */
4170       if ((strncasecmp (name, "argw", 4) == 0))
4171         {
4172           temp = atoi (name + 4);
4173           p = input_line_pointer;
4174           *p = c;
4175           input_line_pointer++;
4176           name = input_line_pointer;
4177           c = get_symbol_end ();
4178           arg_reloc = pa_build_arg_reloc (name);
4179           call_desc->arg_reloc |= pa_align_arg_reloc (temp, arg_reloc);
4180         }
4181       /* Process a return value.  */
4182       else if ((strncasecmp (name, "rtnval", 6) == 0))
4183         {
4184           p = input_line_pointer;
4185           *p = c;
4186           input_line_pointer++;
4187           name = input_line_pointer;
4188           c = get_symbol_end ();
4189           arg_reloc = pa_build_arg_reloc (name);
4190           call_desc->arg_reloc |= (arg_reloc & 0x3);
4191         }
4192       else
4193         {
4194           as_bad ("Invalid .CALL argument: %s", name);
4195         }
4196       p = input_line_pointer;
4197       *p = c;
4198       if (!is_end_of_statement ())
4199         input_line_pointer++;
4200     }
4201 }
4202
4203 /* Return TRUE if FRAG1 and FRAG2 are the same.  */
4204
4205 static int
4206 is_same_frag (frag1, frag2)
4207      fragS *frag1;
4208      fragS *frag2;
4209 {
4210
4211   if (frag1 == NULL)
4212     return (FALSE);
4213   else if (frag2 == NULL)
4214     return (FALSE);
4215   else if (frag1 == frag2)
4216     return (TRUE);
4217   else if (frag2->fr_type == rs_fill && frag2->fr_fix == 0)
4218     return (is_same_frag (frag1, frag2->fr_next));
4219   else
4220     return (FALSE);
4221 }
4222
4223 /* Build an entry in the UNWIND subspace from the given
4224    function attributes in CALL_INFO.  */
4225
4226 static void
4227 pa_build_unwind_subspace (call_info)
4228      struct call_info *call_info;
4229 {
4230   char *unwind;
4231   asection *seg, *save_seg;
4232   subsegT subseg, save_subseg;
4233   int i;
4234   char c, *p;
4235
4236   /* Get into the right seg/subseg.  This may involve creating
4237      the seg the first time through.  Make sure to have the
4238      old seg/subseg so that we can reset things when we are done.  */
4239   subseg = SUBSEG_UNWIND;
4240   seg = bfd_get_section_by_name (stdoutput, UNWIND_SECTION_NAME);
4241   if (seg == ASEC_NULL)
4242     {
4243       seg = bfd_make_section_old_way (stdoutput, UNWIND_SECTION_NAME);
4244       bfd_set_section_flags (stdoutput, seg,
4245                              SEC_READONLY | SEC_HAS_CONTENTS
4246                              | SEC_LOAD | SEC_RELOC);
4247     }
4248
4249   save_seg = now_seg;
4250   save_subseg = now_subseg;
4251   subseg_set (seg, subseg);
4252
4253
4254   /* Get some space to hold relocation information for the unwind
4255      descriptor.  */
4256   p = frag_more (4);
4257   call_info->start_offset_frag = frag_now;
4258   call_info->start_frag_where = p - frag_now->fr_literal;
4259
4260   /* Relocation info. for start offset of the function.  */
4261   fix_new_hppa (frag_now, p - frag_now->fr_literal, 4,
4262                 call_info->start_symbol, (offsetT) 0,
4263                 (expressionS *) NULL, 0, R_HPPA_UNWIND, e_fsel, 32, 0,
4264                 (char *) 0);
4265
4266   /* We need to search for the first relocation involving the start_symbol of
4267      this call_info descriptor.  */
4268   {
4269     fixS *fixP;
4270
4271     call_info->start_fix = seg_info (now_seg)->fix_root;
4272     for (fixP = call_info->start_fix; fixP; fixP = fixP->fx_next)
4273       {
4274         if (fixP->fx_addsy == call_info->start_symbol
4275             || fixP->fx_subsy == call_info->start_symbol)
4276           {
4277             call_info->start_fix = fixP;
4278             break;
4279           }
4280       }
4281   }
4282
4283   p = frag_more (4);
4284   call_info->end_offset_frag = frag_now;
4285   call_info->end_frag_where = p - frag_now->fr_literal;
4286
4287   /* Relocation info. for end offset of the function.  */
4288   fix_new_hppa (frag_now, p - frag_now->fr_literal, 4,
4289                 call_info->end_symbol, (offsetT) 0,
4290                 (expressionS *) NULL, 0, R_HPPA_UNWIND, e_fsel, 32, 0,
4291                 (char *) 0);
4292
4293   /* We need to search for the first relocation involving the end_symbol of
4294      this call_info descriptor.  */
4295   {
4296     fixS *fixP;
4297
4298     call_info->end_fix = seg_info (now_seg)->fix_root;  /* the default */
4299     for (fixP = call_info->end_fix; fixP; fixP = fixP->fx_next)
4300       {
4301         if (fixP->fx_addsy == call_info->end_symbol
4302             || fixP->fx_subsy == call_info->end_symbol)
4303           {
4304             call_info->end_fix = fixP;
4305             break;
4306           }
4307       }
4308   }
4309
4310   /* callinfo.frame is in bytes and unwind_desc is in 8 byte units.  */
4311   call_info->ci_unwind.descriptor.frame_size = call_info->frame / 8;
4312
4313   /* Dump it. */
4314   unwind = (char *) &call_info->ci_unwind;
4315   for (i = 8; i < sizeof (struct unwind_table); i++)
4316     {
4317       c = *(unwind + i);
4318       {
4319         FRAG_APPEND_1_CHAR (c);
4320       }
4321     }
4322
4323   /* Return back to the original segment/subsegment.  */
4324   subseg_set (save_seg, save_subseg);
4325 }
4326
4327 /* Process a .CALLINFO pseudo-op.  This information is used later
4328    to build unwind descriptors and maybe one day to support
4329    .ENTER and .LEAVE.  */
4330
4331 static void
4332 pa_callinfo (unused)
4333      int unused;
4334 {
4335   char *name, c, *p;
4336   int temp;
4337
4338   /* .CALLINFO must appear within a procedure definition.  */
4339   if (!within_procedure)
4340     as_bad (".callinfo is not within a procedure definition");
4341
4342   /* Mark the fact that we found the .CALLINFO for the
4343      current procedure.  */
4344   callinfo_found = TRUE;
4345
4346   /* Iterate over the .CALLINFO arguments.  */
4347   while (!is_end_of_statement ())
4348     {
4349       name = input_line_pointer;
4350       c = get_symbol_end ();
4351       /* Frame size specification.  */
4352       if ((strncasecmp (name, "frame", 5) == 0))
4353         {
4354           p = input_line_pointer;
4355           *p = c;
4356           input_line_pointer++;
4357           temp = get_absolute_expression ();
4358           if ((temp & 0x3) != 0)
4359             {
4360               as_bad ("FRAME parameter must be a multiple of 8: %d\n", temp);
4361               temp = 0;
4362             }
4363           last_call_info->frame = temp;
4364         }
4365       /* Entry register (GR, GR and SR) specifications.  */
4366       else if ((strncasecmp (name, "entry_gr", 8) == 0))
4367         {
4368           p = input_line_pointer;
4369           *p = c;
4370           input_line_pointer++;
4371           temp = get_absolute_expression ();
4372           /* The HP assembler accepts 19 as the high bound for ENTRY_GR
4373              even though %r19 is caller saved.  I think this is a bug in
4374              the HP assembler, and we are not going to emulate it.  */
4375           if (temp < 3 || temp > 18)
4376             as_bad ("Value for ENTRY_GR must be in the range 3..18\n");
4377           last_call_info->ci_unwind.descriptor.entry_gr = temp - 2;
4378         }
4379       else if ((strncasecmp (name, "entry_fr", 8) == 0))
4380         {
4381           p = input_line_pointer;
4382           *p = c;
4383           input_line_pointer++;
4384           temp = get_absolute_expression ();
4385           /* Similarly the HP assembler takes 31 as the high bound even
4386              though %fr21 is the last callee saved floating point register.  */
4387           if (temp < 12 || temp > 21)
4388             as_bad ("Value for ENTRY_FR must be in the range 12..21\n");
4389           last_call_info->ci_unwind.descriptor.entry_fr = temp - 11;
4390         }
4391       else if ((strncasecmp (name, "entry_sr", 8) == 0))
4392         {
4393           p = input_line_pointer;
4394           *p = c;
4395           input_line_pointer++;
4396           temp = get_absolute_expression ();
4397           if (temp != 3)
4398             as_bad ("Value for ENTRY_SR must be 3\n");
4399           last_call_info->entry_sr = temp - 2;
4400         }
4401       /* Note whether or not this function performs any calls.  */
4402       else if ((strncasecmp (name, "calls", 5) == 0) ||
4403                (strncasecmp (name, "caller", 6) == 0))
4404         {
4405           p = input_line_pointer;
4406           *p = c;
4407           last_call_info->makes_calls = 1;
4408         }
4409       else if ((strncasecmp (name, "no_calls", 8) == 0))
4410         {
4411           p = input_line_pointer;
4412           *p = c;
4413           last_call_info->makes_calls = 0;
4414         }
4415       /* Should RP be saved into the stack.  */
4416       else if ((strncasecmp (name, "save_rp", 7) == 0))
4417         {
4418           p = input_line_pointer;
4419           *p = c;
4420           last_call_info->ci_unwind.descriptor.save_rp = 1;
4421         }
4422       /* Likewise for SP.  */
4423       else if ((strncasecmp (name, "save_sp", 7) == 0))
4424         {
4425           p = input_line_pointer;
4426           *p = c;
4427           last_call_info->ci_unwind.descriptor.save_sp = 1;
4428         }
4429       /* Is this an unwindable procedure.  If so mark it so
4430          in the unwind descriptor.  */
4431       else if ((strncasecmp (name, "no_unwind", 9) == 0))
4432         {
4433           p = input_line_pointer;
4434           *p = c;
4435           last_call_info->ci_unwind.descriptor.cannot_unwind = 1;
4436         }
4437       /* Is this an interrupt routine.  If so mark it in the
4438          unwind descriptor.  */
4439       else if ((strncasecmp (name, "hpux_int", 7) == 0))
4440         {
4441           p = input_line_pointer;
4442           *p = c;
4443           last_call_info->ci_unwind.descriptor.hpux_interrupt_marker = 1;
4444         }
4445       else
4446         {
4447           as_bad ("Invalid .CALLINFO argument: %s", name);
4448         }
4449       if (!is_end_of_statement ())
4450         input_line_pointer++;
4451     }
4452
4453   demand_empty_rest_of_line ();
4454   return;
4455 }
4456
4457 /* Switch into the code subspace.  */
4458
4459 static void
4460 pa_code (unused)
4461      int unused;
4462 {
4463   sd_chain_struct *sdchain;
4464
4465   /* First time through it might be necessary to create the
4466      $TEXT$ space.  */
4467   if ((sdchain = is_defined_space ("$TEXT$")) == NULL)
4468     {
4469       sdchain = create_new_space (pa_def_spaces[0].name,
4470                                   pa_def_spaces[0].spnum,
4471                                   pa_def_spaces[0].loadable,
4472                                   pa_def_spaces[0].defined,
4473                                   pa_def_spaces[0].private,
4474                                   pa_def_spaces[0].sort,
4475                                   pa_def_spaces[0].segment, 0);
4476     }
4477
4478   SPACE_DEFINED (sdchain) = 1;
4479   subseg_set (text_section, SUBSEG_CODE);
4480   demand_empty_rest_of_line ();
4481   return;
4482 }
4483
4484 /* This is different than the standard GAS s_comm(). On HP9000/800 machines,
4485    the .comm pseudo-op has the following symtax:
4486
4487    <label> .comm <length>
4488
4489    where <label> is optional and is a symbol whose address will be the start of
4490    a block of memory <length> bytes long. <length> must be an absolute
4491    expression.  <length> bytes will be allocated in the current space
4492    and subspace.  */
4493
4494 static void
4495 pa_comm (unused)
4496      int unused;
4497 {
4498   unsigned int size;
4499   symbolS *symbol;
4500   label_symbol_struct *label_symbol = pa_get_label ();
4501
4502   if (label_symbol)
4503     symbol = label_symbol->lss_label;
4504   else
4505     symbol = NULL;
4506
4507   SKIP_WHITESPACE ();
4508   size = get_absolute_expression ();
4509
4510   if (symbol)
4511     {
4512       /* It is incorrect to check S_IS_DEFINED at this point as
4513          the symbol will *always* be defined.  FIXME.  How to
4514          correctly determine when this label really as been
4515          defined before.  */
4516       if (S_GET_VALUE (symbol))
4517         {
4518           if (S_GET_VALUE (symbol) != size)
4519             {
4520               as_warn ("Length of .comm \"%s\" is already %d. Not changed.",
4521                        S_GET_NAME (symbol), S_GET_VALUE (symbol));
4522               return;
4523             }
4524         }
4525       else
4526         {
4527           S_SET_VALUE (symbol, size);
4528           S_SET_SEGMENT (symbol, &bfd_und_section);
4529           S_SET_EXTERNAL (symbol);
4530         }
4531     }
4532   demand_empty_rest_of_line ();
4533 }
4534
4535 /* Process a .COPYRIGHT pseudo-op.  */
4536
4537 static void
4538 pa_copyright (unused)
4539      int unused;
4540 {
4541   char *name;
4542   char c;
4543
4544   SKIP_WHITESPACE ();
4545   if (*input_line_pointer == '\"')
4546     {
4547       ++input_line_pointer;
4548       name = input_line_pointer;
4549       while ((c = next_char_of_string ()) >= 0)
4550         ;
4551       c = *input_line_pointer;
4552       *input_line_pointer = '\0';
4553       *(input_line_pointer - 1) = '\0';
4554       {
4555         /* FIXME.  Not supported */
4556         abort ();
4557       }
4558       *input_line_pointer = c;
4559     }
4560   else
4561     {
4562       as_bad ("Expected \"-ed string");
4563     }
4564   pa_undefine_label ();
4565   demand_empty_rest_of_line ();
4566 }
4567
4568 /* Process a .END pseudo-op.  */
4569
4570 static void
4571 pa_end (unused)
4572      int unused;
4573 {
4574   demand_empty_rest_of_line ();
4575   return;
4576 }
4577
4578 /* Process a .ENTER pseudo-op.  This is not supported.  */
4579 static void
4580 pa_enter (unused)
4581      int unused;
4582 {
4583   abort();
4584   return;
4585 }
4586
4587 /* Process a .ENTRY pseudo-op.  .ENTRY marks the beginning of the
4588    procesure.  */
4589 static void
4590 pa_entry (unused)
4591      int unused;
4592 {
4593   char *where;
4594
4595   if (!within_procedure)
4596     as_bad ("Misplaced .entry. Ignored.");
4597   else
4598     {
4599       if (!callinfo_found)
4600         as_bad ("Missing .callinfo.");
4601
4602       last_call_info->start_frag = frag_now;
4603     }
4604   demand_empty_rest_of_line ();
4605   within_entry_exit = TRUE;
4606   where = frag_more (0);
4607
4608   /* Go back to the last symbol and turn on the BSF_FUNCTION flag.
4609      It will not be on if no .EXPORT pseudo-op exists (static function).  */
4610   last_call_info->start_symbol->bsym->flags |= BSF_FUNCTION;
4611
4612   return;
4613 }
4614
4615 /* Handle a .EQU pseudo-op.  */
4616
4617 static void
4618 pa_equ (reg)
4619      int reg;
4620 {
4621   label_symbol_struct *label_symbol = pa_get_label ();
4622   symbolS *symbol;
4623
4624   if (label_symbol)
4625     {
4626       symbol = label_symbol->lss_label;
4627       S_SET_VALUE (symbol, (unsigned int) get_absolute_expression ());
4628       S_SET_SEGMENT (symbol, &bfd_abs_section);
4629     }
4630   else
4631     {
4632       if (reg)
4633         as_bad (".REG must use a label");
4634       else
4635         as_bad (".EQU must use a label");
4636     }
4637
4638   pa_undefine_label ();
4639   demand_empty_rest_of_line ();
4640   return;
4641 }
4642
4643 /* Helper function.  Does processing for the end of a function.  This
4644    usually involves creating some relocations or building special
4645    symbols to mark the end of the function.  */
4646
4647 static void
4648 process_exit ()
4649 {
4650   char *where;
4651
4652   where = frag_more (0);
4653
4654   /* ELF does not have EXIT relocations.  All we do is create a
4655      temporary symbol marking the end of the function.  */
4656   {
4657     char *name = (char *) xmalloc (strlen ("L\001end_") +
4658                     strlen (S_GET_NAME (last_call_info->start_symbol)) + 1);
4659
4660     if (name)
4661       {
4662         symbolS *symbolP;
4663
4664         strcpy (name, "L\001end_");
4665         strcat (name, S_GET_NAME (last_call_info->start_symbol));
4666
4667         symbolP = symbol_find (name);
4668         if (symbolP)
4669           as_warn ("Symbol '%s' already defined.", name);
4670         else
4671           {
4672             /* symbol value should be the offset of the
4673                last instruction of the function */
4674             symbolP = symbol_new (name, now_seg,
4675                                   (valueT) (obstack_next_free (&frags)
4676                                             - frag_now->fr_literal - 4),
4677                                   frag_now);
4678
4679             assert (symbolP);
4680             symbolP->bsym->flags = BSF_LOCAL;
4681             symbol_table_insert (symbolP);
4682           }
4683         if (symbolP)
4684           last_call_info->end_symbol = symbolP;
4685         else
4686           as_bad ("Symbol '%s' could not be created.", name);
4687
4688       }
4689     else
4690       as_bad ("No memory for symbol name.");
4691   }
4692
4693   /* Stuff away the location of the frag for the end of the function,
4694      and call pa_build_unwind_subspace to add an entry in the unwind
4695      table.  */
4696   last_call_info->end_frag = frag_now;
4697   pa_build_unwind_subspace (last_call_info);
4698   exit_processing_complete = TRUE;
4699 }
4700
4701 /* Process a .EXIT pseudo-op.  */
4702
4703 static void
4704 pa_exit (unused)
4705      int unused;
4706 {
4707   if (!within_procedure)
4708     as_bad (".EXIT must appear within a procedure");
4709   else
4710     {
4711       if (!callinfo_found)
4712         as_bad ("Missing .callinfo");
4713       else
4714         {
4715           if (!within_entry_exit)
4716             as_bad ("No .ENTRY for this .EXIT");
4717           else
4718             {
4719               within_entry_exit = FALSE;
4720               process_exit ();
4721             }
4722         }
4723     }
4724   demand_empty_rest_of_line ();
4725   return;
4726 }
4727
4728 /* Process a .EXPORT directive.  This makes functions external
4729    and provides information such as argument relocation entries
4730    to callers.  */
4731
4732 static void
4733 pa_export (unused)
4734      int unused;
4735 {
4736   char *name, c, *p;
4737   symbolS *symbol;
4738
4739   name = input_line_pointer;
4740   c = get_symbol_end ();
4741   /* Make sure the given symbol exists.  */
4742   if ((symbol = symbol_find_or_make (name)) == NULL)
4743     {
4744       as_bad ("Cannot define export symbol: %s\n", name);
4745       p = input_line_pointer;
4746       *p = c;
4747       input_line_pointer++;
4748     }
4749   else
4750     {
4751       /* OK.  Set the external bits and process argument relocations.  */
4752       S_SET_EXTERNAL (symbol);
4753       p = input_line_pointer;
4754       *p = c;
4755       if (!is_end_of_statement ())
4756         {
4757           input_line_pointer++;
4758           pa_export_args (symbol);
4759 #ifdef OBJ_ELF
4760           pa_build_symextn_section ();
4761 #endif
4762         }
4763     }
4764
4765   demand_empty_rest_of_line ();
4766   return;
4767 }
4768
4769 /* Helper function to process arguments to a .EXPORT pseudo-op.  */
4770
4771 static void
4772 pa_export_args (symbolP)
4773      symbolS *symbolP;
4774 {
4775   char *name, c, *p;
4776   unsigned int temp, arg_reloc;
4777   obj_symbol_type *symbol = (obj_symbol_type *) symbolP->bsym;
4778
4779   if (strncasecmp (input_line_pointer, "absolute", 8) == 0)
4780     {
4781       input_line_pointer += 8;
4782       S_SET_SEGMENT (symbolP, &bfd_abs_section);
4783     }
4784   else if (strncasecmp (input_line_pointer, "code", 4) == 0)
4785     input_line_pointer += 4;
4786   else if (strncasecmp (input_line_pointer, "data", 4) == 0)
4787     input_line_pointer += 4;
4788   else if ((strncasecmp (input_line_pointer, "entry", 5) == 0))
4789     {
4790       input_line_pointer += 5;
4791       symbolP->bsym->flags |= BSF_FUNCTION;
4792     }
4793   else if (strncasecmp (input_line_pointer, "millicode", 9) == 0)
4794     {
4795       input_line_pointer += 9;
4796     }
4797   else if (strncasecmp (input_line_pointer, "plabel", 6) == 0)
4798     {
4799       input_line_pointer += 6;
4800     }
4801   else if (strncasecmp (input_line_pointer, "pri_prog", 8) == 0)
4802     {
4803       input_line_pointer += 8;
4804     }
4805   else if (strncasecmp (input_line_pointer, "sec_prog", 8) == 0)
4806     {
4807       input_line_pointer += 8;
4808     }
4809
4810   /* Now that the type of the exported symbol has been handled,
4811      handle any argument relocation information.  */
4812   while (!is_end_of_statement ())
4813     {
4814       if (*input_line_pointer == ',')
4815         input_line_pointer++;
4816       name = input_line_pointer;
4817       c = get_symbol_end ();
4818       /* Argument sources.  */
4819       if ((strncasecmp (name, "argw", 4) == 0))
4820         {
4821           p = input_line_pointer;
4822           *p = c;
4823           input_line_pointer++;
4824           temp = atoi (name + 4);
4825           name = input_line_pointer;
4826           c = get_symbol_end ();
4827           arg_reloc = pa_align_arg_reloc (temp, pa_build_arg_reloc (name));
4828           symbol->tc_data.hppa_arg_reloc |= arg_reloc;
4829           *input_line_pointer = c;
4830         }
4831       /* The return value.  */
4832       else if ((strncasecmp (name, "rtnval", 6)) == 0)
4833         {
4834           p = input_line_pointer;
4835           *p = c;
4836           input_line_pointer++;
4837           name = input_line_pointer;
4838           c = get_symbol_end ();
4839           arg_reloc = pa_build_arg_reloc (name);
4840           symbol->tc_data.hppa_arg_reloc |= arg_reloc;
4841           *input_line_pointer = c;
4842         }
4843       /* Privelege level.  */
4844       else if ((strncasecmp (name, "priv_lev", 8)) == 0)
4845         {
4846           p = input_line_pointer;
4847           *p = c;
4848           input_line_pointer++;
4849           temp = atoi (input_line_pointer);
4850           c = get_symbol_end ();
4851           *input_line_pointer = c;
4852         }
4853       else
4854         {
4855           as_bad ("Undefined .EXPORT/.IMPORT argument (ignored): %s", name);
4856           p = input_line_pointer;
4857           *p = c;
4858         }
4859       if (!is_end_of_statement ())
4860         input_line_pointer++;
4861     }
4862 }
4863
4864 /* Handle an .IMPORT pseudo-op.  Any symbol referenced in a given
4865    assembly file must either be defined in the assembly file, or
4866    explicitly IMPORTED from another.  */
4867
4868 static void
4869 pa_import (unused)
4870      int unused;
4871 {
4872   char *name, c, *p;
4873   symbolS *symbol;
4874
4875   name = input_line_pointer;
4876   c = get_symbol_end ();
4877
4878   symbol = symbol_find_or_make (name);
4879   p = input_line_pointer;
4880   *p = c;
4881
4882   if (!is_end_of_statement ())
4883     {
4884       input_line_pointer++;
4885       /* Hmmm.  This doesn't look right.  */
4886       pa_export_args (symbol);
4887     }
4888   else
4889     {
4890       /* If the section is undefined, then the symbol is undefined
4891          Since this is an import, leave the section undefined.  */
4892       S_SET_SEGMENT (symbol, &bfd_und_section);
4893     }
4894
4895   demand_empty_rest_of_line ();
4896   return;
4897 }
4898
4899 /* Handle a .LABEL pseudo-op.  */
4900
4901 static void
4902 pa_label (unused)
4903      int unused;
4904 {
4905   char *name, c, *p;
4906
4907   name = input_line_pointer;
4908   c = get_symbol_end ();
4909
4910   if (strlen (name) > 0)
4911     {
4912       colon (name);
4913       p = input_line_pointer;
4914       *p = c;
4915     }
4916   else
4917     {
4918       as_warn ("Missing label name on .LABEL");
4919     }
4920
4921   if (!is_end_of_statement ())
4922     {
4923       as_warn ("extra .LABEL arguments ignored.");
4924       ignore_rest_of_line ();
4925     }
4926   demand_empty_rest_of_line ();
4927   return;
4928 }
4929
4930 /* Handle a .LEAVE pseudo-op.  This is not supported yet.  */
4931
4932 static void
4933 pa_leave (unused)
4934      int unused;
4935 {
4936   abort();
4937 }
4938
4939 /* Handle a .ORIGIN pseudo-op.  */
4940
4941 static void
4942 pa_origin (unused)
4943      int unused;
4944 {
4945   s_org (0);
4946   pa_undefine_label ();
4947   return;
4948 }
4949
4950 /* Handle a .PARAM pseudo-op.  This is much like a .EXPORT, except it
4951    is for static functions.  FIXME.  Should share more code with .EXPORT.  */
4952
4953 static void
4954 pa_param (unused)
4955      int unused;
4956 {
4957   char *name, c, *p;
4958   symbolS *symbol;
4959
4960   name = input_line_pointer;
4961   c = get_symbol_end ();
4962
4963   if ((symbol = symbol_find_or_make (name)) == NULL)
4964     {
4965       as_bad ("Cannot define static symbol: %s\n", name);
4966       p = input_line_pointer;
4967       *p = c;
4968       input_line_pointer++;
4969     }
4970   else
4971     {
4972       S_CLEAR_EXTERNAL (symbol);
4973       p = input_line_pointer;
4974       *p = c;
4975       if (!is_end_of_statement ())
4976         {
4977           input_line_pointer++;
4978           pa_export_args (symbol);
4979         }
4980     }
4981
4982   demand_empty_rest_of_line ();
4983   return;
4984 }
4985
4986 /* Handle a .PROC pseudo-op.  It is used to mark the beginning
4987    of a procedure from a syntatical point of view.  */
4988
4989 static void
4990 pa_proc (unused)
4991      int unused;
4992 {
4993   struct call_info *call_info;
4994
4995   if (within_procedure)
4996     as_fatal ("Nested procedures");
4997
4998   /* Reset global variables for new procedure.  */
4999   callinfo_found = FALSE;
5000   within_procedure = TRUE;
5001   exit_processing_complete = FALSE;
5002
5003   /* Create another call_info structure.  */
5004   call_info = (struct call_info *) xmalloc (sizeof (struct call_info));
5005
5006   if (!call_info)
5007     as_fatal ("Cannot allocate unwind descriptor\n");
5008
5009   bzero (call_info, sizeof (struct call_info));
5010
5011   call_info->ci_next = NULL;
5012
5013   if (call_info_root == NULL)
5014     {
5015       call_info_root = call_info;
5016       last_call_info = call_info;
5017     }
5018   else
5019     {
5020       last_call_info->ci_next = call_info;
5021       last_call_info = call_info;
5022     }
5023
5024   /* set up defaults on call_info structure */
5025
5026   call_info->ci_unwind.descriptor.cannot_unwind = 0;
5027   call_info->ci_unwind.descriptor.region_desc = 1;
5028   call_info->ci_unwind.descriptor.hpux_interrupt_marker = 0;
5029   call_info->entry_sr = ~0;
5030   call_info->makes_calls = 1;
5031
5032   /* If we got a .PROC pseudo-op, we know that the function is defined
5033      locally.  Make sure it gets into the symbol table.  */
5034   {
5035     label_symbol_struct *label_symbol = pa_get_label ();
5036
5037     if (label_symbol)
5038       {
5039         if (label_symbol->lss_label)
5040           {
5041             last_call_info->start_symbol = label_symbol->lss_label;
5042             label_symbol->lss_label->bsym->flags |= BSF_FUNCTION;
5043           }
5044         else
5045           as_bad ("Missing function name for .PROC (corrupted label)");
5046       }
5047     else
5048       as_bad ("Missing function name for .PROC");
5049   }
5050
5051   demand_empty_rest_of_line ();
5052   return;
5053 }
5054
5055 /* Process the syntatical end of a procedure.  Make sure all the
5056    appropriate pseudo-ops were found within the procedure.  */
5057
5058 static void
5059 pa_procend (unused)
5060      int unused;
5061 {
5062
5063   if (!within_procedure)
5064     as_bad ("misplaced .procend");
5065
5066   if (!callinfo_found)
5067     as_bad ("Missing .callinfo for this procedure");
5068
5069   if (within_entry_exit)
5070     as_bad ("Missing .EXIT for a .ENTRY");
5071
5072   if (!exit_processing_complete)
5073     process_exit ();
5074
5075   within_procedure = FALSE;
5076   demand_empty_rest_of_line ();
5077   return;
5078 }
5079
5080 /* Parse the parameters to a .SPACE directive; if CREATE_FLAG is nonzero,
5081    then create a new space entry to hold the information specified
5082    by the parameters to the .SPACE directive.  */
5083
5084 static sd_chain_struct *
5085 pa_parse_space_stmt (space_name, create_flag)
5086      char *space_name;
5087      int create_flag;
5088 {
5089   char *name, *ptemp, c;
5090   char loadable, defined, private, sort;
5091   int spnum;
5092   asection *seg;
5093   sd_chain_struct *space;
5094
5095   /* load default values */
5096   spnum = 0;
5097   loadable = TRUE;
5098   defined = TRUE;
5099   private = FALSE;
5100   if (strcasecmp (space_name, "$TEXT$") == 0)
5101     {
5102       seg = text_section;
5103       sort = 8;
5104     }
5105   else
5106     {
5107       seg = data_section;
5108       sort = 16;
5109     }
5110
5111   if (!is_end_of_statement ())
5112     {
5113       print_errors = FALSE;
5114       ptemp = input_line_pointer + 1;
5115       /* First see if the space was specified as a number rather than
5116          as a name.  According to the PA assembly manual the rest of
5117          the line should be ignored.  */
5118       if ((spnum = pa_parse_number (&ptemp, 0)) >= 0)
5119         input_line_pointer = ptemp;
5120       else
5121         {
5122           while (!is_end_of_statement ())
5123             {
5124               input_line_pointer++;
5125               name = input_line_pointer;
5126               c = get_symbol_end ();
5127               if ((strncasecmp (name, "SPNUM", 5) == 0))
5128                 {
5129                   *input_line_pointer = c;
5130                   input_line_pointer++;
5131                   spnum = get_absolute_expression ();
5132                 }
5133               else if ((strncasecmp (name, "SORT", 4) == 0))
5134                 {
5135                   *input_line_pointer = c;
5136                   input_line_pointer++;
5137                   sort = get_absolute_expression ();
5138                 }
5139               else if ((strncasecmp (name, "UNLOADABLE", 10) == 0))
5140                 {
5141                   *input_line_pointer = c;
5142                   loadable = FALSE;
5143                 }
5144               else if ((strncasecmp (name, "NOTDEFINED", 10) == 0))
5145                 {
5146                   *input_line_pointer = c;
5147                   defined = FALSE;
5148                 }
5149               else if ((strncasecmp (name, "PRIVATE", 7) == 0))
5150                 {
5151                   *input_line_pointer = c;
5152                   private = TRUE;
5153                 }
5154               else
5155                 {
5156                   as_bad ("Invalid .SPACE argument");
5157                   *input_line_pointer = c;
5158                   if (! is_end_of_statement ())
5159                     input_line_pointer++;
5160                 }
5161             }
5162         }
5163       print_errors = TRUE;
5164     }
5165
5166   /* If create_flag is nonzero, then create the new space with
5167      the attributes computed above.  Else set the values in
5168      an already existing space -- this can only happen for
5169      the first occurence of a built-in space.  */
5170   if (create_flag)
5171     space = create_new_space (space_name, spnum, loadable, defined,
5172                               private, sort, seg, 1);
5173   else
5174     {
5175       space = is_defined_space (space_name);
5176       SPACE_SPNUM (space) = spnum;
5177       SPACE_LOADABLE (space) = loadable & 1;
5178       SPACE_DEFINED (space) = defined & 1;
5179       SPACE_USER_DEFINED (space) = 1;
5180       SPACE_PRIVATE (space) = private & 1;
5181       SPACE_SORT (space) = sort & 0xff;
5182       space->sd_seg = seg;
5183     }
5184   return space;
5185 }
5186
5187 /* Adjust the frag's alignment according to the alignment needs
5188    of the given subspace/subsegment.  */
5189
5190 static void
5191 pa_align_subseg (seg, subseg)
5192      asection *seg;
5193      subsegT subseg;
5194 {
5195   ssd_chain_struct *now_subspace;
5196   int alignment;
5197   int shift = 0;
5198
5199   now_subspace = pa_subsegment_to_subspace (seg, subseg);
5200   if (now_subspace)
5201     {
5202       if (SUBSPACE_ALIGN (now_subspace) == 0)
5203         alignment = now_subspace->ssd_last_align;
5204       else if (now_subspace->ssd_last_align > SUBSPACE_ALIGN (now_subspace))
5205         alignment = now_subspace->ssd_last_align;
5206       else
5207         alignment = SUBSPACE_ALIGN (now_subspace);
5208
5209       while ((1 << shift) < alignment)
5210         shift++;
5211     }
5212   else
5213     shift = bfd_get_section_alignment (stdoutput, seg);
5214
5215   frag_align (shift, 0);
5216 }
5217
5218 /* Handle a .SPACE pseudo-op; this switches the current space to the
5219    given space, creating the new space if necessary.  */
5220
5221 static void
5222 pa_space (unused)
5223      int unused;
5224 {
5225   char *name, c, *space_name, *save_s;
5226   int temp;
5227   sd_chain_struct *sd_chain;
5228
5229   if (within_procedure)
5230     {
5231       as_bad ("Can\'t change spaces within a procedure definition. Ignored");
5232       ignore_rest_of_line ();
5233     }
5234   else
5235     {
5236       /* Check for some of the predefined spaces.   FIXME: most of the code
5237          below is repeated several times, can we extract the common parts
5238          and place them into a subroutine or something similar?  */
5239       if (strncasecmp (input_line_pointer, "$text$", 6) == 0)
5240         {
5241           input_line_pointer += 6;
5242           sd_chain = is_defined_space ("$TEXT$");
5243           if (sd_chain == NULL)
5244             sd_chain = pa_parse_space_stmt ("$TEXT$", 1);
5245           else if (SPACE_USER_DEFINED (sd_chain) == 0)
5246             sd_chain = pa_parse_space_stmt ("$TEXT$", 0);
5247
5248           current_space = sd_chain;
5249
5250           /* No need to align if we are already there.  */
5251           if (now_seg != text_section)
5252             pa_align_subseg (now_seg, now_subseg);
5253
5254           subseg_set (text_section, sd_chain->sd_last_subseg);
5255
5256           current_subspace
5257             = pa_subsegment_to_subspace (text_section,
5258                                          sd_chain->sd_last_subseg);
5259           demand_empty_rest_of_line ();
5260           return;
5261         }
5262       if (strncasecmp (input_line_pointer, "$private$", 9) == 0)
5263         {
5264           input_line_pointer += 9;
5265           sd_chain = is_defined_space ("$PRIVATE$");
5266           if (sd_chain == NULL)
5267             sd_chain = pa_parse_space_stmt ("$PRIVATE$", 1);
5268           else if (SPACE_USER_DEFINED (sd_chain) == 0)
5269             sd_chain = pa_parse_space_stmt ("$PRIVATE$", 0);
5270
5271           current_space = sd_chain;
5272
5273           /* No need to align if we are already there.  */
5274           if (now_seg != data_section)
5275             pa_align_subseg (now_seg, now_subseg);
5276
5277           subseg_set (data_section, sd_chain->sd_last_subseg);
5278           current_subspace
5279             = pa_subsegment_to_subspace (data_section,
5280                                          sd_chain->sd_last_subseg);
5281           demand_empty_rest_of_line ();
5282           return;
5283         }
5284       if (!strncasecmp (input_line_pointer,
5285                         GDB_DEBUG_SPACE_NAME,
5286                         strlen (GDB_DEBUG_SPACE_NAME)))
5287         {
5288           input_line_pointer += strlen (GDB_DEBUG_SPACE_NAME);
5289           sd_chain = is_defined_space (GDB_DEBUG_SPACE_NAME);
5290           if (sd_chain == NULL)
5291             sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 1);
5292           else if (SPACE_USER_DEFINED (sd_chain) == 0)
5293             sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 0);
5294
5295           current_space = sd_chain;
5296
5297           {
5298             asection *gdb_section
5299             = bfd_make_section_old_way (stdoutput, GDB_DEBUG_SPACE_NAME);
5300
5301             /* No need to align if we are already there.  */
5302             if (strcmp (segment_name (now_seg), GDB_DEBUG_SPACE_NAME) != 0)
5303               pa_align_subseg (now_seg, now_subseg);
5304
5305             subseg_set (gdb_section, sd_chain->sd_last_subseg);
5306             current_subspace
5307               = pa_subsegment_to_subspace (gdb_section,
5308                                            sd_chain->sd_last_subseg);
5309           }
5310           demand_empty_rest_of_line ();
5311           return;
5312         }
5313
5314       /* It could be a space specified by number.  */
5315       print_errors = 0;
5316       save_s = input_line_pointer;
5317       if ((temp = pa_parse_number (&input_line_pointer, 0)) >= 0)
5318         {
5319           if (sd_chain = pa_find_space_by_number (temp))
5320             {
5321               current_space = sd_chain;
5322
5323               if (now_seg != sd_chain->sd_seg)
5324                 pa_align_subseg (now_seg, now_subseg);
5325               subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
5326               current_subspace
5327                 = pa_subsegment_to_subspace (sd_chain->sd_seg,
5328                                              sd_chain->sd_last_subseg);
5329               demand_empty_rest_of_line ();
5330               return;
5331             }
5332         }
5333
5334       /* Not a number, attempt to create a new space.  */
5335       print_errors = 1;
5336       input_line_pointer = save_s;
5337       name = input_line_pointer;
5338       c = get_symbol_end ();
5339       space_name = xmalloc (strlen (name) + 1);
5340       strcpy (space_name, name);
5341       *input_line_pointer = c;
5342
5343       sd_chain = pa_parse_space_stmt (space_name, 1);
5344       current_space = sd_chain;
5345
5346       if (now_seg != sd_chain->sd_seg)
5347         pa_align_subseg (now_seg, now_subseg);
5348       subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
5349       current_subspace = pa_subsegment_to_subspace (sd_chain->sd_seg,
5350                                                   sd_chain->sd_last_subseg);
5351       demand_empty_rest_of_line ();
5352     }
5353   return;
5354 }
5355
5356 /* Switch to a new space.  (I think).  FIXME.  */
5357
5358 static void
5359 pa_spnum (unused)
5360      int unused;
5361 {
5362   char *name;
5363   char c;
5364   char *p;
5365   sd_chain_struct *space;
5366
5367   name = input_line_pointer;
5368   c = get_symbol_end ();
5369   space = is_defined_space (name);
5370   if (space)
5371     {
5372       p = frag_more (4);
5373       md_number_to_chars (p, SPACE_SPNUM (space), 4);
5374     }
5375   else
5376     as_warn ("Undefined space: '%s' Assuming space number = 0.", name);
5377
5378   *input_line_pointer = c;
5379   demand_empty_rest_of_line ();
5380   return;
5381 }
5382
5383 /* If VALUE is an exact power of two between zero and 2^31, then
5384    return log2 (VALUE).  Else return -1.  */
5385
5386 static int
5387 log2 (value)
5388      int value;
5389 {
5390   int shift = 0;
5391
5392   while ((1 << shift) != value && shift < 32)
5393     shift++;
5394
5395   if (shift >= 32)
5396     return -1;
5397   else
5398     return shift;
5399 }
5400
5401 /* Handle a .SPACE pseudo-op; this switches the current subspace to the
5402    given subspace, creating the new subspace if necessary.
5403
5404    FIXME.  Should mirror pa_space more closely, in particular how
5405    they're broken up into subroutines.  */
5406
5407 static void
5408 pa_subspace (unused)
5409      int unused;
5410 {
5411   char *name, *ss_name, c;
5412   char loadable, code_only, common, dup_common, zero, sort;
5413   int i, access, space_index, alignment, quadrant;
5414   sd_chain_struct *space;
5415   ssd_chain_struct *ssd;
5416
5417   if (within_procedure)
5418     {
5419       as_bad ("Can\'t change subspaces within a procedure definition. Ignored");
5420       ignore_rest_of_line ();
5421     }
5422   else
5423     {
5424       name = input_line_pointer;
5425       c = get_symbol_end ();
5426       ss_name = xmalloc (strlen (name) + 1);
5427       strcpy (ss_name, name);
5428       *input_line_pointer = c;
5429
5430       /* Load default values.  */
5431       sort = 0;
5432       access = 0x7f;
5433       loadable = 1;
5434       common = 0;
5435       dup_common = 0;
5436       code_only = 0;
5437       zero = 0;
5438       space_index = ~0;
5439       alignment = 0;
5440       quadrant = 0;
5441
5442       space = pa_segment_to_space (now_seg);
5443       ssd = is_defined_subspace (name, space->sd_last_subseg);
5444       if (ssd)
5445         {
5446           subseg_set (ssd->ssd_seg, ssd->ssd_subseg);
5447           if (!is_end_of_statement ())
5448             as_warn ("Parameters of an existing subspace can\'t be modified");
5449           demand_empty_rest_of_line ();
5450           return;
5451         }
5452       else
5453         {
5454           /* A new subspace.  Load default values.  */
5455           i = 0;
5456           while (pa_def_subspaces[i].name)
5457             {
5458               if (strcasecmp (pa_def_subspaces[i].name, ss_name) == 0)
5459                 {
5460                   loadable = pa_def_subspaces[i].loadable;
5461                   common = pa_def_subspaces[i].common;
5462                   dup_common = pa_def_subspaces[i].dup_common;
5463                   code_only = pa_def_subspaces[i].code_only;
5464                   zero = pa_def_subspaces[i].zero;
5465                   space_index = pa_def_subspaces[i].space_index;
5466                   alignment = pa_def_subspaces[i].alignment;
5467                   quadrant = pa_def_subspaces[i].quadrant;
5468                   access = pa_def_subspaces[i].access;
5469                   sort = pa_def_subspaces[i].sort;
5470                   break;
5471                 }
5472               i++;
5473             }
5474         }
5475
5476       /* We should be working with a new subspace now.  Fill in
5477          any information as specified by the user.  */
5478       if (!is_end_of_statement ())
5479         {
5480           input_line_pointer++;
5481           while (!is_end_of_statement ())
5482             {
5483               name = input_line_pointer;
5484               c = get_symbol_end ();
5485               if ((strncasecmp (name, "QUAD", 4) == 0))
5486                 {
5487                   *input_line_pointer = c;
5488                   input_line_pointer++;
5489                   quadrant = get_absolute_expression ();
5490                 }
5491               else if ((strncasecmp (name, "ALIGN", 5) == 0))
5492                 {
5493                   *input_line_pointer = c;
5494                   input_line_pointer++;
5495                   alignment = get_absolute_expression ();
5496                   if (log2 (alignment) == -1)
5497                     {
5498                       as_bad ("Alignment must be a power of 2");
5499                       alignment = 1;
5500                     }
5501                 }
5502               else if ((strncasecmp (name, "ACCESS", 6) == 0))
5503                 {
5504                   *input_line_pointer = c;
5505                   input_line_pointer++;
5506                   access = get_absolute_expression ();
5507                 }
5508               else if ((strncasecmp (name, "SORT", 4) == 0))
5509                 {
5510                   *input_line_pointer = c;
5511                   input_line_pointer++;
5512                   sort = get_absolute_expression ();
5513                 }
5514               else if ((strncasecmp (name, "CODE_ONLY", 9) == 0))
5515                 {
5516                   *input_line_pointer = c;
5517                   code_only = 1;
5518                 }
5519               else if ((strncasecmp (name, "UNLOADABLE", 10) == 0))
5520                 {
5521                   *input_line_pointer = c;
5522                   loadable = 0;
5523                 }
5524               else if ((strncasecmp (name, "COMMON", 6) == 0))
5525                 {
5526                   *input_line_pointer = c;
5527                   common = 1;
5528                 }
5529               else if ((strncasecmp (name, "DUP_COMM", 8) == 0))
5530                 {
5531                   *input_line_pointer = c;
5532                   dup_common = 1;
5533                 }
5534               else if ((strncasecmp (name, "ZERO", 4) == 0))
5535                 {
5536                   *input_line_pointer = c;
5537                   zero = 1;
5538                 }
5539               else if ((strncasecmp (name, "FIRST", 5) == 0))
5540                 as_bad ("FIRST not supported as a .SUBSPACE argument");
5541               else
5542                 as_bad ("Invalid .SUBSPACE argument");
5543               if (!is_end_of_statement ())
5544                 input_line_pointer++;
5545             }
5546         }
5547
5548       /* Now that all the flags are set, update an existing subspace,
5549          or create a new one with the given flags if the subspace does
5550          not currently exist.  */
5551       space = pa_segment_to_space (now_seg);
5552       if (ssd)
5553         current_subspace = update_subspace (ss_name, loadable, code_only,
5554                                             common, dup_common, sort, zero,
5555                                             access, space_index, alignment,
5556                                             quadrant, ssd->ssd_subseg);
5557       else
5558         current_subspace = create_new_subspace (space, ss_name, loadable,
5559                                                 code_only, common,
5560                                                 dup_common, zero, sort,
5561                                                 access, space_index,
5562                                               alignment, quadrant, now_seg);
5563       SUBSPACE_SUBSPACE_START (current_subspace) = pa_subspace_start (space,
5564                                                                   quadrant);
5565
5566       demand_empty_rest_of_line ();
5567       subseg_set (current_subspace->ssd_seg, current_subspace->ssd_subseg);
5568     }
5569   return;
5570 }
5571
5572
5573 /* Create default space and subspace dictionaries.  */
5574
5575 static void
5576 pa_spaces_begin ()
5577 {
5578   sd_chain_struct *space;
5579   int i;
5580
5581   space_dict_root = NULL;
5582   space_dict_last = NULL;
5583
5584   i = 0;
5585   while (pa_def_spaces[i].name)
5586     {
5587       if (pa_def_spaces[i].alias)
5588         pa_def_spaces[i].segment = subseg_new (pa_def_spaces[i].alias, 0);
5589       else
5590         pa_def_spaces[i].segment
5591           = bfd_make_section_old_way (stdoutput, pa_def_spaces[i].name);
5592
5593       create_new_space (pa_def_spaces[i].name, pa_def_spaces[i].spnum,
5594                         pa_def_spaces[i].loadable, pa_def_spaces[i].defined,
5595                         pa_def_spaces[i].private, pa_def_spaces[i].sort,
5596                         pa_def_spaces[i].segment, 0);
5597       i++;
5598     }
5599
5600   i = 0;
5601   while (pa_def_subspaces[i].name)
5602     {
5603       space = pa_segment_to_space (pa_def_spaces[pa_def_subspaces[i].def_space_index].segment);
5604       if (space)
5605         {
5606           char *name = pa_def_subspaces[i].alias;
5607           if (!name)
5608             name = pa_def_subspaces[i].name;
5609           create_new_subspace (space, name,
5610                                pa_def_subspaces[i].loadable,
5611                                pa_def_subspaces[i].code_only,
5612                                pa_def_subspaces[i].common,
5613                                pa_def_subspaces[i].dup_common,
5614                                pa_def_subspaces[i].zero,
5615                                pa_def_subspaces[i].sort,
5616                                pa_def_subspaces[i].access,
5617                                pa_def_subspaces[i].space_index,
5618                                pa_def_subspaces[i].alignment,
5619                                pa_def_subspaces[i].quadrant,
5620                                pa_def_spaces[pa_def_subspaces[i].def_space_index].segment);
5621           subseg_new (name, pa_def_subspaces[i].subsegment);
5622         }
5623       else
5624         as_fatal ("Internal error: space missing for subspace \"%s\"\n",
5625                   pa_def_subspaces[i].name);
5626       i++;
5627     }
5628 }
5629
5630
5631
5632 /* Create a new space NAME, with the appropriate flags as defined
5633    by the given parameters.
5634
5635    Add the new space to the space dictionary chain in numerical
5636    order as defined by the SORT entries.  */
5637
5638 static sd_chain_struct *
5639 create_new_space (name, spnum, loadable, defined, private,
5640                   sort, seg, user_defined)
5641      char *name;
5642      int spnum;
5643      char loadable;
5644      char defined;
5645      char private;
5646      char sort;
5647      asection *seg;
5648      int user_defined;
5649 {
5650   sd_chain_struct *chain_entry;
5651
5652   chain_entry = (sd_chain_struct *) xmalloc (sizeof (sd_chain_struct));
5653   if (!chain_entry)
5654     as_fatal ("Out of memory: could not allocate new space chain entry: %s\n",
5655               name);
5656
5657   SPACE_NAME (chain_entry) = (char *) xmalloc (strlen (name) + 1);
5658   strcpy (SPACE_NAME (chain_entry), name);
5659   SPACE_NAME_INDEX (chain_entry) = 0;
5660   SPACE_LOADABLE (chain_entry) = loadable;
5661   SPACE_DEFINED (chain_entry) = defined;
5662   SPACE_USER_DEFINED (chain_entry) = user_defined;
5663   SPACE_PRIVATE (chain_entry) = private;
5664   SPACE_SPNUM (chain_entry) = spnum;
5665   SPACE_SORT (chain_entry) = sort;
5666
5667   chain_entry->sd_seg = seg;
5668   chain_entry->sd_last_subseg = -1;
5669   chain_entry->sd_next = NULL;
5670
5671   /* Find spot for the new space based on its sort key.  */
5672   if (!space_dict_last)
5673     space_dict_last = chain_entry;
5674
5675   if (space_dict_root == NULL)
5676     space_dict_root = chain_entry;
5677   else
5678     {
5679       sd_chain_struct *chain_pointer;
5680       sd_chain_struct *prev_chain_pointer;
5681
5682       chain_pointer = space_dict_root;
5683       prev_chain_pointer = NULL;
5684
5685       while (chain_pointer)
5686         {
5687           if (SPACE_SORT (chain_pointer) <= SPACE_SORT (chain_entry))
5688             {
5689               prev_chain_pointer = chain_pointer;
5690               chain_pointer = chain_pointer->sd_next;
5691             }
5692           else
5693             break;
5694         }
5695
5696       /* At this point we've found the correct place to add the new
5697          entry.  So add it and update the linked lists as appropriate.  */
5698       if (prev_chain_pointer)
5699         {
5700           chain_entry->sd_next = chain_pointer;
5701           prev_chain_pointer->sd_next = chain_entry;
5702         }
5703       else
5704         {
5705           space_dict_root = chain_entry;
5706           chain_entry->sd_next = chain_pointer;
5707         }
5708
5709       if (chain_entry->sd_next == NULL)
5710         space_dict_last = chain_entry;
5711     }
5712
5713   return chain_entry;
5714 }
5715
5716 /* Create a new subspace NAME, with the appropriate flags as defined
5717    by the given parameters.
5718
5719    Add the new subspace to the subspace dictionary chain in numerical
5720    order as defined by the SORT entries.  */
5721
5722 static ssd_chain_struct *
5723 create_new_subspace (space, name, loadable, code_only, common,
5724                      dup_common, is_zero, sort, access, space_index,
5725                      alignment, quadrant, seg)
5726      sd_chain_struct *space;
5727      char *name;
5728      char loadable, code_only, common, dup_common, is_zero;
5729      char sort;
5730      int access;
5731      int space_index;
5732      int alignment;
5733      int quadrant;
5734      asection *seg;
5735 {
5736   ssd_chain_struct *chain_entry;
5737   symbolS *start_symbol;
5738
5739   chain_entry = (ssd_chain_struct *) xmalloc (sizeof (ssd_chain_struct));
5740   if (!chain_entry)
5741     as_fatal ("Out of memory: could not allocate new subspace chain entry: %s\n", name);
5742
5743   SUBSPACE_NAME (chain_entry) = (char *) xmalloc (strlen (name) + 1);
5744   strcpy (SUBSPACE_NAME (chain_entry), name);
5745
5746   SUBSPACE_ACCESS (chain_entry) = access;
5747   SUBSPACE_LOADABLE (chain_entry) = loadable;
5748   SUBSPACE_COMMON (chain_entry) = common;
5749   SUBSPACE_DUP_COMM (chain_entry) = dup_common;
5750   SUBSPACE_SORT (chain_entry) = sort;
5751   SUBSPACE_CODE_ONLY (chain_entry) = code_only;
5752   SUBSPACE_ALIGN (chain_entry) = alignment;
5753   SUBSPACE_QUADRANT (chain_entry) = quadrant;
5754   SUBSPACE_SUBSPACE_START (chain_entry) = pa_subspace_start (space, quadrant);
5755   SUBSPACE_SPACE_INDEX (chain_entry) = space_index;
5756   SUBSPACE_ZERO (chain_entry) = is_zero;
5757
5758   chain_entry->ssd_subseg = pa_next_subseg (space);
5759   chain_entry->ssd_seg = seg;
5760   chain_entry->ssd_last_align = 1;
5761   chain_entry->ssd_next = NULL;
5762
5763   /* Find spot for the new subspace based on its sort key.  */
5764   if (space->sd_subspaces == NULL)
5765     space->sd_subspaces = chain_entry;
5766   else
5767     {
5768       ssd_chain_struct *chain_pointer;
5769       ssd_chain_struct *prev_chain_pointer;
5770
5771       chain_pointer = space->sd_subspaces;
5772       prev_chain_pointer = NULL;
5773
5774       while (chain_pointer)
5775         {
5776           if (SUBSPACE_SORT (chain_pointer) <= SUBSPACE_SORT (chain_entry))
5777             {
5778               prev_chain_pointer = chain_pointer;
5779               chain_pointer = chain_pointer->ssd_next;
5780             }
5781           else
5782             break;
5783
5784         }
5785
5786       /* Now we have somewhere to put the new entry.  Insert it and update
5787          the links.  */
5788       if (prev_chain_pointer)
5789         {
5790           chain_entry->ssd_next = chain_pointer;
5791           prev_chain_pointer->ssd_next = chain_entry;
5792         }
5793       else
5794         {
5795           space->sd_subspaces = chain_entry;
5796           chain_entry->ssd_next = chain_pointer;
5797         }
5798     }
5799
5800   return chain_entry;
5801
5802 }
5803
5804 /* Update the information for the given subspace based upon the
5805    various arguments.   Return the modified subspace chain entry.  */
5806
5807 static ssd_chain_struct *
5808 update_subspace (name, loadable, code_only, common, dup_common, sort,
5809                  zero, access, space_index, alignment, quadrant, subseg)
5810      char *name;
5811      char loadable;
5812      char code_only;
5813      char common;
5814      char dup_common;
5815      char zero;
5816      char sort;
5817      int access;
5818      int space_index;
5819      int alignment;
5820      int quadrant;
5821      subsegT subseg;
5822 {
5823   ssd_chain_struct *chain_entry;
5824
5825   if ((chain_entry = is_defined_subspace (name, subseg)))
5826     {
5827       SUBSPACE_ACCESS (chain_entry) = access;
5828       SUBSPACE_LOADABLE (chain_entry) = loadable;
5829       SUBSPACE_COMMON (chain_entry) = common;
5830       SUBSPACE_DUP_COMM (chain_entry) = dup_common;
5831       SUBSPACE_CODE_ONLY (chain_entry) = 1;
5832       SUBSPACE_SORT (chain_entry) = sort;
5833       SUBSPACE_ALIGN (chain_entry) = alignment;
5834       SUBSPACE_QUADRANT (chain_entry) = quadrant;
5835       SUBSPACE_SPACE_INDEX (chain_entry) = space_index;
5836       SUBSPACE_ZERO (chain_entry) = zero;
5837     }
5838   else
5839     chain_entry = NULL;
5840
5841   return chain_entry;
5842
5843 }
5844
5845 /* Return the space chain entry for the space with the name NAME or
5846    NULL if no such space exists.  */
5847
5848 static sd_chain_struct *
5849 is_defined_space (name)
5850      char *name;
5851 {
5852   sd_chain_struct *chain_pointer;
5853
5854   for (chain_pointer = space_dict_root;
5855        chain_pointer;
5856        chain_pointer = chain_pointer->sd_next)
5857     {
5858       if (strcmp (SPACE_NAME (chain_pointer), name) == 0)
5859         return chain_pointer;
5860     }
5861
5862   /* No mapping from segment to space was found.  Return NULL.  */
5863   return NULL;
5864 }
5865
5866 /* Find and return the space associated with the given seg.  If no mapping
5867    from the given seg to a space is found, then return NULL.
5868
5869    Unlike subspaces, the number of spaces is not expected to grow much,
5870    so a linear exhaustive search is OK here.  */
5871
5872 static sd_chain_struct *
5873 pa_segment_to_space (seg)
5874      asection *seg;
5875 {
5876   sd_chain_struct *space_chain;
5877
5878   /* Walk through each space looking for the correct mapping.  */
5879   for (space_chain = space_dict_root;
5880        space_chain;
5881        space_chain = space_chain->sd_next)
5882     {
5883       if (space_chain->sd_seg == seg)
5884         return space_chain;
5885     }
5886
5887   /* Mapping was not found.  Return NULL.  */
5888   return NULL;
5889 }
5890
5891 /* Return the space chain entry for the subspace with the name NAME or
5892    NULL if no such subspace exists.
5893
5894    Uses a linear search through all the spaces and subspaces, this may
5895    not be appropriate if we ever being placing each function in its
5896    own subspace.  */
5897
5898 static ssd_chain_struct *
5899 is_defined_subspace (name, subseg)
5900      char *name;
5901      subsegT subseg;
5902 {
5903   sd_chain_struct*space_chain;
5904   ssd_chain_struct *subspace_chain;
5905
5906   /* Walk through each space.  */
5907   for (space_chain = space_dict_root;
5908        space_chain;
5909        space_chain = space_chain->sd_next)
5910     {
5911       /* Walk through each subspace looking for a name which matches.  */
5912       for (subspace_chain = space_chain->sd_subspaces;
5913            subspace_chain;
5914            subspace_chain = subspace_chain->ssd_next)
5915         if (strcmp (SUBSPACE_NAME (subspace_chain), name) == 0)
5916           return subspace_chain;
5917     }
5918
5919   /* Subspace wasn't found.  Return NULL.  */
5920   return NULL;
5921 }
5922
5923 /* Find and return the subspace associated with the given seg.  If no
5924    mapping from the given seg to a subspace is found, then return NULL.
5925
5926    If we ever put each procedure/function within its own subspace
5927    (to make life easier on the compiler and linker), then this will have
5928    to become more efficient.  */
5929
5930 static ssd_chain_struct *
5931 pa_subsegment_to_subspace (seg, subseg)
5932      asection *seg;
5933      subsegT subseg;
5934 {
5935   sd_chain_struct *space_chain;
5936   ssd_chain_struct *subspace_chain;
5937
5938   /* Walk through each space.  */
5939   for (space_chain = space_dict_root;
5940        space_chain;
5941        space_chain = space_chain->sd_next)
5942     {
5943       if (space_chain->sd_seg == seg)
5944         {
5945           /* Walk through each subspace within each space looking for
5946              the correct mapping.  */
5947           for (subspace_chain = space_chain->sd_subspaces;
5948                subspace_chain;
5949                subspace_chain = subspace_chain->ssd_next)
5950             if (subspace_chain->ssd_subseg == (int) subseg)
5951               return subspace_chain;
5952         }
5953     }
5954
5955   /* No mapping from subsegment to subspace found.  Return NULL.  */
5956   return NULL;
5957 }
5958
5959 /* Given a number, try and find a space with the name number.
5960
5961    Return a pointer to a space dictionary chain entry for the space
5962    that was found or NULL on failure.  */
5963
5964 static sd_chain_struct *
5965 pa_find_space_by_number (number)
5966      int number;
5967 {
5968   sd_chain_struct *space_chain;
5969
5970   for (space_chain = space_dict_root;
5971        space_chain;
5972        space_chain = space_chain->sd_next)
5973     {
5974       if (SPACE_SPNUM (space_chain) == number)
5975         return space_chain;
5976     }
5977
5978   /* No appropriate space found.  Return NULL.  */
5979   return NULL;
5980 }
5981
5982 /* Return the starting address for the given subspace.  If the starting
5983    address is unknown then return zero.  */
5984
5985 static unsigned int
5986 pa_subspace_start (space, quadrant)
5987      sd_chain_struct *space;
5988      int quadrant;
5989 {
5990   /* FIXME.  Assumes everyone puts read/write data at 0x4000000, this
5991      is not correct for the PA OSF1 port.  */
5992   if ((strcasecmp (SPACE_NAME (space), "$PRIVATE$") == 0) && quadrant == 1)
5993     return 0x40000000;
5994   else if (space->sd_seg == data_section && quadrant == 1)
5995     return 0x40000000;
5996   else
5997     return 0;
5998 }
5999
6000 /* FIXME.  Needs documentation.  */
6001 static int
6002 pa_next_subseg (space)
6003      sd_chain_struct *space;
6004 {
6005
6006   space->sd_last_subseg++;
6007   return space->sd_last_subseg;
6008 }
6009
6010 /* Helper function for pa_stringer.  Used to find the end of
6011    a string.  */
6012
6013 static unsigned int
6014 pa_stringer_aux (s)
6015      char *s;
6016 {
6017   unsigned int c = *s & CHAR_MASK;
6018   switch (c)
6019     {
6020     case '\"':
6021       c = NOT_A_CHAR;
6022       break;
6023     default:
6024       break;
6025     }
6026   return c;
6027 }
6028
6029 /* Handle a .STRING type pseudo-op.  */
6030
6031 static void
6032 pa_stringer (append_zero)
6033      int append_zero;
6034 {
6035   char *s, num_buf[4];
6036   unsigned int c;
6037   int i;
6038
6039   /* Preprocess the string to handle PA-specific escape sequences.
6040      For example, \xDD where DD is a hexidecimal number should be
6041      changed to \OOO where OOO is an octal number.  */
6042
6043   /* Skip the opening quote.  */
6044   s = input_line_pointer + 1;
6045
6046   while (is_a_char (c = pa_stringer_aux (s++)))
6047     {
6048       if (c == '\\')
6049         {
6050           c = *s;
6051           switch (c)
6052             {
6053               /* Handle \x<num>.  */
6054             case 'x':
6055               {
6056                 unsigned int number;
6057                 int num_digit;
6058                 char dg;
6059                 char *s_start = s;
6060
6061                 /* Get pas the 'x'.  */
6062                 s++;
6063                 for (num_digit = 0, number = 0, dg = *s;
6064                      num_digit < 2
6065                      && (isdigit (dg) || (dg >= 'a' && dg <= 'f')
6066                          || (dg >= 'A' && dg <= 'F'));
6067                      num_digit++)
6068                   {
6069                     if (isdigit (dg))
6070                       number = number * 16 + dg - '0';
6071                     else if (dg >= 'a' && dg <= 'f')
6072                       number = number * 16 + dg - 'a' + 10;
6073                     else
6074                       number = number * 16 + dg - 'A' + 10;
6075
6076                     s++;
6077                     dg = *s;
6078                   }
6079                 if (num_digit > 0)
6080                   {
6081                     switch (num_digit)
6082                       {
6083                       case 1:
6084                         sprintf (num_buf, "%02o", number);
6085                         break;
6086                       case 2:
6087                         sprintf (num_buf, "%03o", number);
6088                         break;
6089                       }
6090                     for (i = 0; i <= num_digit; i++)
6091                       s_start[i] = num_buf[i];
6092                   }
6093                 break;
6094               }
6095             /* This might be a "\"", skip over the escaped char.  */
6096             default:
6097               s++;
6098               break;
6099             }
6100         }
6101     }
6102   stringer (append_zero);
6103   pa_undefine_label ();
6104 }
6105
6106 /* Handle a .VERSION pseudo-op.  */
6107
6108 static void
6109 pa_version (unused)
6110      int unused;
6111 {
6112   obj_version (0);
6113   pa_undefine_label ();
6114 }
6115
6116 /* Just like a normal cons, but when finished we have to undefine
6117    the latest space label.  */
6118
6119 static void
6120 pa_cons (nbytes)
6121      int nbytes;
6122 {
6123   cons (nbytes);
6124   pa_undefine_label ();
6125 }
6126
6127 /* Switch to the data space.  As usual delete our label.  */
6128
6129 static void
6130 pa_data (unused)
6131      int unused;
6132 {
6133   s_data (0);
6134   pa_undefine_label ();
6135 }
6136
6137 /* FIXME.  What's the purpose of this pseudo-op?  */
6138
6139 static void
6140 pa_desc (unused)
6141      int unused;
6142 {
6143   pa_undefine_label ();
6144 }
6145
6146 /* Like float_cons, but we need to undefine our label.  */
6147
6148 static void
6149 pa_float_cons (float_type)
6150      int float_type;
6151 {
6152   float_cons (float_type);
6153   pa_undefine_label ();
6154 }
6155
6156 /* Like s_fill, but delete our label when finished.  */
6157
6158 static void
6159 pa_fill (unused)
6160      int unused;
6161 {
6162   s_fill (0);
6163   pa_undefine_label ();
6164 }
6165
6166 /* Like lcomm, but delete our label when finished.  */
6167
6168 static void
6169 pa_lcomm (needs_align)
6170      int needs_align;
6171 {
6172   s_lcomm (needs_align);
6173   pa_undefine_label ();
6174 }
6175
6176 /* Like lsym, but delete our label when finished.  */
6177
6178 static void
6179 pa_lsym (unused)
6180      int unused;
6181 {
6182   s_lsym (0);
6183   pa_undefine_label ();
6184 }
6185
6186 /* Switch to the text space.  Like s_text, but delete our
6187    label when finished.  */
6188 static void
6189 pa_text (unused)
6190      int unused;
6191 {
6192   s_text (0);
6193   pa_undefine_label ();
6194 }
6195
6196 /* On the PA relocations which involve function symbols must not be
6197    adjusted.  This so that the linker can know when/how to create argument
6198    relocation stubs for indirect calls and calls to static functions.
6199
6200    FIXME.  Also reject R_HPPA relocations which are 32 bits
6201    wide.  Helps with code lables in arrays for SOM.  (SOM BFD code
6202    needs to generate relocations to push the addend and symbol value
6203    onto the stack, add them, then pop the value off the stack and
6204    use it in a relocation -- yuk.  */
6205
6206 int
6207 hppa_fix_adjustable (fixp)
6208      fixS *fixp;
6209 {
6210   struct hppa_fix_struct *hppa_fix;
6211
6212   hppa_fix = fixp->tc_fix_data;
6213
6214   if (fixp->fx_r_type == R_HPPA && hppa_fix->fx_r_format == 32)
6215     return 0;
6216
6217   if (fixp->fx_addsy == 0
6218       || (fixp->fx_addsy->bsym->flags & BSF_FUNCTION) == 0)
6219     return 1;
6220
6221   return 0;
6222 }
6223
6224 /* Now for some ELF specific code.  FIXME.  */
6225 #ifdef OBJ_ELF
6226 static symext_chainS *symext_rootP;
6227 static symext_chainS *symext_lastP;
6228
6229 /* Do any symbol processing requested by the target-cpu or target-format.  */
6230
6231 void
6232 hppa_tc_symbol (abfd, symbolP, sym_idx)
6233      bfd *abfd;
6234      elf_symbol_type *symbolP;
6235      int sym_idx;
6236 {
6237   symext_chainS *symextP;
6238   unsigned int arg_reloc;
6239
6240   /* Only functions can have argument relocations.  */
6241   if (!(symbolP->symbol.flags & BSF_FUNCTION))
6242     return;
6243
6244   arg_reloc = symbolP->tc_data.hppa_arg_reloc;
6245
6246   /* If there are no argument relocation bits, then no relocation is
6247      necessary.  Do not add this to the symextn section.  */
6248   if (arg_reloc == 0)
6249     return;
6250
6251   symextP = (symext_chainS *) bfd_alloc (abfd, sizeof (symext_chainS) * 2);
6252
6253   symextP[0].entry = ELF32_HPPA_SX_WORD (HPPA_SXT_SYMNDX, sym_idx);
6254   symextP[0].next = &symextP[1];
6255
6256   symextP[1].entry = ELF32_HPPA_SX_WORD (HPPA_SXT_ARG_RELOC, arg_reloc);
6257   symextP[1].next = NULL;
6258
6259   if (symext_rootP == NULL)
6260     {
6261       symext_rootP = &symextP[0];
6262       symext_lastP = &symextP[1];
6263     }
6264   else
6265     {
6266       symext_lastP->next = &symextP[0];
6267       symext_lastP = &symextP[1];
6268     }
6269 }
6270
6271 /* Make sections needed by the target cpu and/or target format.  */
6272 void
6273 hppa_tc_make_sections (abfd)
6274      bfd *abfd;
6275 {
6276   symext_chainS *symextP;
6277   int size, n;
6278   asection *symextn_sec;
6279   segT save_seg = now_seg;
6280   subsegT save_subseg = now_subseg;
6281
6282   /* Build the symbol extension section.  */
6283   hppa_tc_make_symextn_section ();
6284
6285   /* Force some calculation to occur.  */
6286   bfd_set_section_contents (stdoutput, stdoutput->sections, "", 0, 0);
6287
6288   hppa_elf_stub_finish (abfd);
6289
6290   /* If no symbols for the symbol extension section, then stop now.  */
6291   if (symext_rootP == NULL)
6292     return;
6293
6294   /* Count the number of symbols for the symbol extension section.  */
6295   for (n = 0, symextP = symext_rootP; symextP; symextP = symextP->next, ++n)
6296     ;
6297
6298   size = sizeof (symext_entryS) * n;
6299
6300   /* Switch to the symbol extension section.  */
6301   symextn_sec = subseg_new (SYMEXTN_SECTION_NAME, 0);
6302
6303   frag_wane (frag_now);
6304   frag_new (0);
6305
6306   for (symextP = symext_rootP; symextP; symextP = symextP->next)
6307     {
6308       char *ptr;
6309       int *symtab_map = elf_sym_extra (abfd);
6310       int idx;
6311
6312       /* First, patch the symbol extension record to reflect the true
6313          symbol table index.  */
6314
6315       if (ELF32_HPPA_SX_TYPE (symextP->entry) == HPPA_SXT_SYMNDX)
6316         {
6317           idx = ELF32_HPPA_SX_VAL (symextP->entry) - 1;
6318           symextP->entry = ELF32_HPPA_SX_WORD (HPPA_SXT_SYMNDX,
6319                                                symtab_map[idx]);
6320         }
6321
6322       ptr = frag_more (sizeof (symextP->entry));
6323       md_number_to_chars (ptr, symextP->entry, sizeof (symextP->entry));
6324     }
6325
6326   frag_now->fr_fix = obstack_next_free (&frags) - frag_now->fr_literal;
6327   frag_wane (frag_now);
6328
6329   /* Switch back to the original segment.  */
6330   subseg_set (save_seg, save_subseg);
6331
6332   return;
6333 }
6334
6335 /* Make the symbol extension section.  */
6336
6337 static void
6338 hppa_tc_make_symextn_section ()
6339 {
6340   if (symext_rootP)
6341     {
6342       symext_chainS *symextP;
6343       int n;
6344       unsigned int size;
6345       segT symextn_sec;
6346       segT save_seg = now_seg;
6347       subsegT save_subseg = now_subseg;
6348
6349       for (n = 0, symextP = symext_rootP; symextP; symextP = symextP->next, ++n)
6350         ;
6351
6352       size = sizeof (symext_entryS) * n;
6353
6354       symextn_sec = subseg_new (SYMEXTN_SECTION_NAME, 0);
6355
6356       bfd_set_section_flags (stdoutput, symextn_sec,
6357                              SEC_LOAD | SEC_HAS_CONTENTS | SEC_DATA);
6358       bfd_set_section_size (stdoutput, symextn_sec, size);
6359
6360       /* Now, switch back to the original segment.  */
6361       subseg_set (save_seg, save_subseg);
6362     }
6363 }
6364
6365 /* Build the symbol extension section.  */
6366
6367 static void
6368 pa_build_symextn_section ()
6369 {
6370   segT seg;
6371   asection *save_seg = now_seg;
6372   subsegT subseg = (subsegT) 0;
6373   subsegT save_subseg = now_subseg;
6374
6375   seg = subseg_new (".hppa_symextn", subseg);
6376   bfd_set_section_flags (stdoutput,
6377                          seg,
6378                          SEC_HAS_CONTENTS | SEC_READONLY
6379                          | SEC_ALLOC | SEC_LOAD);
6380
6381   subseg_set (save_seg, save_subseg);
6382
6383 }
6384
6385 /* For ELF, this function serves one purpose:  to setup the st_size
6386    field of STT_FUNC symbols.  To do this, we need to scan the
6387    call_info structure list, determining st_size in one of two possible
6388    ways:
6389
6390    1. call_info->start_frag->fr_fix has the size of the fragment.
6391    This approach assumes that the function was built into a
6392    single fragment.  This works for most cases, but might fail.
6393    For example, if there was a segment change in the middle of
6394    the function.
6395
6396    2. The st_size field is the difference in the addresses of the
6397    call_info->start_frag->fr_address field and the fr_address
6398    field of the next fragment with fr_type == rs_fill and
6399    fr_fix != 0.  */
6400
6401 void
6402 elf_hppa_final_processing ()
6403 {
6404   struct call_info *call_info_pointer;
6405
6406   for (call_info_pointer = call_info_root;
6407        call_info_pointer;
6408        call_info_pointer = call_info_pointer->ci_next)
6409     {
6410       elf_symbol_type *esym
6411         = (elf_symbol_type *) call_info_pointer->start_symbol->bsym;
6412       esym->internal_elf_sym.st_size =
6413         S_GET_VALUE (call_info_pointer->end_symbol)
6414           - S_GET_VALUE (call_info_pointer->start_symbol) + 4;
6415     }
6416 }
6417 #endif