From Jeff Law and Pete Hoogenboom at Utah:

[thirdparty/binutils-gdb.git] / gas / config / tc-hppa.c

/* tc-hppa.c -- Assemble for the PA
   Copyright (C) 1989 Free Software Foundation, Inc.

This file is part of GAS, the GNU Assembler.

GAS is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.

GAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GAS; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */


/*
   HP PA-RISC support was contributed by the Center for Software Science
   at the University of Utah.
 */

#include <stdio.h>
#include <ctype.h>

#include "as.h"
#include "subsegs.h"

#include "../bfd/libhppa.h"

#ifdef OBJ_ELF
#include "../bfd/elf32-hppa.h"
#endif

/*
 * Unwind table and descriptor.
 */

struct unwind_desc
  {
    unsigned int cannot_unwind:1;
    unsigned int millicode:1;
    unsigned int millicode_save_rest:1;
    unsigned int region_desc:2;
    unsigned int save_sr:2;
    unsigned int entry_fr:4;	/* number saved */
    unsigned int entry_gr:5;	/* number saved */
    unsigned int args_stored:1;
    unsigned int call_fr:5;
    unsigned int call_gr:5;
    unsigned int save_sp:1;
    unsigned int save_rp:1;
    unsigned int save_rp_in_frame:1;
    unsigned int extn_ptr_defined:1;
    unsigned int cleanup_defined:1;

    unsigned int hpe_interrupt_marker:1;
    unsigned int hpux_interrupt_marker:1;
    unsigned int reserved:3;
    unsigned int frame_size:27;
  };

typedef struct unwind_desc unwind_descS;

struct unwind_table
  {
    unsigned int start_offset;	/* starting offset (from SR4) of applicable region */
    unsigned int end_offset;	/* ending offset (from SR4) of applicable region */
    unwind_descS descriptor;
  };

typedef struct unwind_table unwind_tableS;

/*
 * This structure is used by the .callinfo, .enter, .leave pseudo-ops to
 * control the entry and exit code they generate. It is also used in
 * creation of the correct stack unwind descriptors.
 *
 * The fields in structure roughly correspond to the arguments available on the
 * .callinfo pseudo-op.
 */

struct call_info
  {
    int frame;
    int entry_sr;
    int makes_calls;
    int hpux_int;
    unwind_tableS ci_unwind;	/* the unwind descriptor we are building */
    symbolS *start_symbol;	/* name of function (used in relocation info) */
    symbolS *end_symbol;	/* temporary symbol used to mark the */
    /* end of the function (used in */
    /* relocation info) */
    fragS *start_frag;		/* frag associated w/ start of this function */
    fragS *end_frag;		/* frag associated w/ end of this function */
    fragS *start_offset_frag;	/* frag for start offset of this descriptor */
    int start_frag_where;	/* where in start_offset_frag is start_offset */
    fixS *start_fix;		/* fixup for the start_offset */
    fragS *end_offset_frag;	/* frag for start offset of this descriptor */
    int end_frag_where;		/* where in end_offset_frag is end_offset */
    fixS *end_fix;		/* fixup for the end_offset */
    struct call_info *ci_next;	/* the next call_info structure */
  };

typedef struct call_info call_infoS;

call_infoS *last_call_info;
call_infoS *call_info_root;
call_descS last_call_desc;

/* A structure used during assembly of individual instructions */

struct pa_it
  {
    char *error;
    unsigned long opcode;
    /* symbol_dictS *nlistp; *//*** used to be:    struct nlist *nlistp; */
    asymbol *nlistp;
    expressionS exp;
    int pcrel;
    FP_Operand_Format fpof1;	/* Floating Point Operand Format, operand 1 */
    FP_Operand_Format fpof2;	/* Floating Point Operand Format, operand 2 */
    /* (used only for class 1 instructions --   */
    /* the conversion instructions)             */
#ifdef OBJ_SOM
    long field_selector;
    unsigned int reloc;
    int code;
    long arg_reloc;
    unwind_descS unwind;
#endif
#ifdef OBJ_ELF
    elf32_hppa_reloc_type reloc;
    long field_selector;
    int format;
    long arg_reloc;
    unwind_descS unwind;
#endif
  };

extern struct pa_it the_insn;

/* careful, this file includes data *declarations* */
#include "opcode/hppa.h"

void md_begin ();
void md_end ();
void md_number_to_chars ();
void md_assemble ();
char *md_atof ();
void md_convert_frag ();
void md_create_short_jump ();
void md_create_long_jump ();
int md_estimate_size_before_relax ();
void md_number_to_imm ();
void md_number_to_disp ();
void md_number_to_field ();
void md_ri_to_chars ();
void emit_relocations ();
static void pa_ip ();
static void hppa_tc_make_symextn_section ();

const relax_typeS md_relax_table[] = {0};
/* handle of the OPCODE hash table */
static struct hash_control *op_hash = NULL;

int md_short_jump_size = 4;
int md_long_jump_size = 4;

/* This array holds the chars that always start a comment.  If the
    pre-processor is disabled, these aren't very useful */
const char comment_chars[] = ";";	/* JF removed '|' from comment_chars */

const pseudo_typeS
  md_pseudo_table[] =
{
  {"align", s_align_bytes, 0},	/* .align 4 means .align to 4-byte boundary */
  {"ALIGN", s_align_bytes, 0},	/* .align 4 means .align to 4-byte boundary */
  {"block", pa_block, 1},
  {"BLOCK", pa_block, 1},
  {"blockz", pa_block, 0},
  {"BLOCKZ", pa_block, 0},
  {"byte", pa_cons, 1},
  {"BYTE", pa_cons, 1},
  {"call", pa_call, 0},
  {"CALL", pa_call, 0},
  {"callinfo", pa_callinfo, 0},
  {"CALLINFO", pa_callinfo, 0},
  {"code", pa_code, 0},
  {"CODE", pa_code, 0},
  {"comm", pa_comm, 0},
  {"COMM", pa_comm, 0},
  {"copyright", pa_copyright, 0},
  {"COPYRIGHT", pa_copyright, 0},
  {"data", pa_data, 0},
  {"DATA", pa_data, 0},
  {"desc", pa_desc, 0},
  {"DESC", pa_desc, 0},
  {"double", pa_float_cons, 'd'},
  {"DOUBLE", pa_float_cons, 'd'},
  {"end", pa_end, 0},
  {"END", pa_end, 0},
  {"enter", pa_enter, 0},
  {"ENTER", pa_enter, 0},
  {"entry", pa_entry, 0},
  {"ENTRY", pa_entry, 0},
  {"equ", pa_equ, 0},
  {"EQU", pa_equ, 0},
  {"exit", pa_exit, 0},
  {"EXIT", pa_exit, 0},
  {"export", pa_export, 0},
  {"EXPORT", pa_export, 0},
  {"fill", pa_fill, 0},
  {"FILL", pa_fill, 0},
  {"float", pa_float_cons, 'f'},
  {"FLOAT", pa_float_cons, 'f'},
  {"half", pa_cons, 2},
  {"HALF", pa_cons, 2},
  {"import", pa_import, 0},
  {"IMPORT", pa_import, 0},
  {"int", pa_cons, 4},
  {"INT", pa_cons, 4},
  {"label", pa_label, 0},
  {"LABEL", pa_label, 0},
  {"lcomm", pa_lcomm, 0},
  {"LCOMM", pa_lcomm, 0},
  {"leave", pa_leave, 0},
  {"LEAVE", pa_leave, 0},
  {"long", pa_cons, 4},
  {"LONG", pa_cons, 4},
  {"lsym", pa_lsym, 0},
  {"LSYM", pa_lsym, 0},
  {"octa", pa_cons, 16},
  {"OCTA", pa_cons, 16},
  {"org", pa_origin, 0},
  {"ORG", pa_origin, 0},
  {"origin", pa_origin, 0},
  {"ORIGIN", pa_origin, 0},
  {"param", pa_param, 0},
  {"PARAM", pa_param, 0},
  {"proc", pa_proc, 0},
  {"PROC", pa_proc, 0},
  {"procend", pa_procend, 0},
  {"PROCEND", pa_procend, 0},
  {"quad", pa_cons, 8},
  {"QUAD", pa_cons, 8},
  {"reg", pa_equ, 1},		/* very similar to .equ */
  {"REG", pa_equ, 1},		/* very similar to .equ */
  {"short", pa_cons, 2},
  {"SHORT", pa_cons, 2},
  {"single", pa_float_cons, 'f'},
  {"SINGLE", pa_float_cons, 'f'},
  {"space", pa_space, 0},
  {"SPACE", pa_space, 0},
  {"spnum", pa_spnum, 0},
  {"SPNUM", pa_spnum, 0},
  {"string", pa_stringer, 0},
  {"STRING", pa_stringer, 0},
  {"stringz", pa_stringer, 1},
  {"STRINGZ", pa_stringer, 1},
  {"subspa", pa_subspace, 0},
  {"SUBSPA", pa_subspace, 0},
  {"text", pa_text, 0},
  {"TEXT", pa_text, 0},
  {"version", pa_version, 0},
  {"VERSION", pa_version, 0},
  {"word", pa_cons, 4},
  {"WORD", pa_cons, 4},
  {NULL, 0, 0}
};

/* This array holds the chars that only start a comment at the beginning of
   a line.  If the line seems to have the form '# 123 filename'
   .line and .file directives will appear in the pre-processed output */
/* Note that input_file.c hand checks for '#' at the beginning of the
   first line of the input file.  This is because the compiler outputs
   #NO_APP at the beginning of its output. */
/* Also note that '/*' will always start a comment */
const char line_comment_chars[] = "#";

const char line_separator_chars[] = "!";

/* Chars that can be used to separate mant from exp in floating point nums */
const char EXP_CHARS[] = "eE";

/* Chars that mean this number is a floating point constant */
/* As in 0f12.456 */
/* or    0d1.2345e12 */
const char FLT_CHARS[] = "rRsSfFdDxXpP";

/* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
   changed in read.c .  Ideally it shouldn't have to know about it at all,
   but nothing is ideal around here.
 */

static unsigned char octal[256];
#ifndef isoctal
#define isoctal(c)  octal[c]
#endif
static unsigned char toHex[256];

struct pa_it set_insn;		/* this structure is defined above */

/* SKV 12/22/92.  Added prev_insn, prev_fix, and initialized the_insn
   so that we can recognize instruction sequences such as (ldil, ble)
   and generate the appropriate fixups. */

struct pa_it the_insn =
{
  NULL,				/* error */
  0,				/* opcode */
  NULL,				/* nlistp */
  {
    O_illegal,			/* exp.X_op */
    NULL,			/* exp.X_add_symbol */
    NULL,			/* exp.X_op_symbol */
    0,				/* exp.X_add_number */
  },
  0,				/* pcrel */
  0,				/* fpof1 */
  0,				/* fpof2 */
  0,				/* reloc */
  0,				/* field_selector */
  0,				/* code */
  0,				/* arg_reloc */
  {				/* unwind */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  }
};

#ifdef OBJ_ELF

struct pa_it prev_insn;
char prev_str[10] = "";
fixS *prev_fix = NULL;
fixS *curr_fix = NULL;

#endif /* OBJ_ELF */

#ifdef __STDC__
void print_insn (struct pa_it *insn);
#else
void print_insn ();
#endif
char *expr_end;

static symbolS *label_symbolP;	/* the last label symbol encountered */
/* saved here in case a .equ is encountered */
static int label_symbol_defined;

/* T if a .callinfo appeared within the current procedure definition
   and F otherwise.  */
static int callinfo_found;

/* T if the assembler is currently within a .entry/.exit pair and F
   otherwise.  */
static int within_entry_exit;

/* T is the assembler has completed exit processing for the current
   procedure and F otherwise.  */
static int exit_processing_complete;

/* T if the assembler is currently within a procedure definition and
   F otherwise.  */
static int within_procedure;

void ignore_rest_of_line ();	/* a useful function in read.c */

/* default space and subspace dictionaries */

#define GDB_SYMBOLS          GDB_SYMBOLS_SUBSPACE_NAME
#define GDB_STRINGS          GDB_STRINGS_SUBSPACE_NAME

#if defined(OBJ_ELF)
static struct default_subspace_dict pa_def_subspaces[] =
{
  {"$CODE$",    0, 1, 0, 0, 0, 0,  24, 0x2c, 0, 8, 0, 0, ".text",	 SUBSEG_CODE},
  {"$DATA$",    0, 1, 0, 0, 0, 0,  24, 0x1f, 0, 8, 1, 1, ".data",	 SUBSEG_DATA},
  {"$LIT$",     0, 1, 0, 0, 0, 0,  16, 0x2c, 0, 8, 0, 0, ".text",	 SUBSEG_LIT},
  {"$BSS$",     0, 1, 0, 0, 0, 1,  80, 0x1f, 0, 8, 1, 1, ".bss",	 SUBSEG_BSS},
  {"$UNWIND$",  0, 1, 0, 0, 0, 0,  64, 0x2c, 0, 4, 0, 0, ".hppa_unwind", SUBSEG_UNWIND},
  {NULL,        0, 1, 0, 0, 0, 0, 255, 0x1f, 0, 4, 0, 0, 0,              0}
};

static struct default_space_dict pa_def_spaces[] =
{
  {"$TEXT$",    0, 1, 0, 0,  8, ASEC_NULL, ".text"},
  {"$PRIVATE$", 0, 1, 0, 0, 16, ASEC_NULL, ".data"},
  {NULL,        0, 0, 0, 0,  0, ASEC_NULL, NULL}
};
#else
static struct default_subspace_dict pa_def_subspaces[] =
{
  {"$CODE$",    0, 1, 0, 0, 0, 0,  24, 0x2c, 0, 8, 0, SEG_TEXT, SUBSEG_CODE},
  {"$DATA$",    0, 1, 0, 0, 0, 0,  24, 0x1f, 0, 8, 1, SEG_DATA, SUBSEG_DATA},
  {"$LIT$",     0, 1, 0, 0, 0, 0,  16, 0x2c, 0, 8, 0, SEG_TEXT, SUBSEG_LIT},
  {"$BSS$",     0, 1, 0, 0, 0, 1,  80, 0x1f, 0, 8, 1, SEG_DATA, SUBSEG_BSS},
  {"$UNWIND$",  0, 1, 0, 0, 0, 0,  64, 0x2c, 0, 4, 0, SEG_TEXT, SUBSEG_UNWIND},
  {GDB_STRINGS, 0, 0, 0, 0, 0, 0, 254, 0x1f, 0, 4, 0, SEG_GDB,  SUBSEG_GDB_STRINGS},
  {GDB_SYMBOLS, 0, 0, 0, 0, 0, 0, 255, 0x1f, 0, 4, 0, SEG_GDB,  SUBSEG_GDB_SYMBOLS},
  {NULL,        0, 1, 0, 0, 0, 0, 255, 0x1f, 0, 4, 0, SEG_GOOF, 0}
};

static struct default_space_dict pa_def_spaces[] =
{
  {"$TEXT$",             0, 1, 0, 0,   8, SEG_TEXT},
  {"$PRIVATE$",          0, 1, 0, 0,  16, SEG_DATA},
  {GDB_DEBUG_SPACE_NAME, 0, 0, 0, 0, 255, SEG_GDB},
  {NULL,                 0, 0, 0, 0,   0, SEG_GOOF}
};
#endif

#ifndef FALSE
#define FALSE   (0)
#define TRUE    (!FALSE)
#endif /* no FALSE yet */

/*
	Support for keeping track of the most recent label in each
	space.
 */

/*
	PA_PSEUDO_OP_MOVES_PC

	A predicate that returns true if the pseudo-operation or
	assembly directive results in a movement in the current
	location.  All instructions cause movement in the current
	location.
 */

static const char *const movers[] =
{
/* these entries from 'static pseudo_typeS potable[]' in pa-read.c */
  "ascii", "asciz",
  "byte",
  "comm",
  "data", "desc", "double",
  "fill", "float",
  "globl",
  "half",
  "int",
  "lcomm", "long", "lsym",
  "octa", "org",
  "quad",
  "short", "single",
  "text",
  "word",
/* these entries from 'pseudo_typeS md_pseudo_table[]' in pa-aux.c */
  "block", "blockz",
  "code", "copyright",
  "equ",
  "origin",
  "reg",			/* very similar to .equ */
  "string", "stringz",
  "version",
  NULL				/* end sentinel */
};

static int
pa_pseudo_op_moves_pc (name)
     char *name;
{
  int i = 0;
  while (movers[i])
    {
      if (strcmp (name, movers[i++]) == 0)
	return 1;
    }

  return 0;
}

/* Support for keeping track of the most recent label in each
   space.  */

/* XXX:  NOTE:  label_symbolS is defined in pa.h */

static label_symbolS *label_symbols_rootP;

/*
	PA_GET_LABEL

	Returns a pointer to the label_symbolS for the current space.
 */

static label_symbolS *
pa_get_label ()
{
  label_symbolS *lssP;
  space_dict_chainS *now_sdcP = pa_segment_to_space (now_seg);

  for (lssP = label_symbols_rootP; lssP; lssP = lssP->lss_next)
    {
      if (now_sdcP == lssP->lss_space && lssP->lss_label)
	return lssP;
    }

  return (label_symbolS *) NULL;
}

/*
	PA_LABEL_IS_DEFINED

	A predicate to determine whether a useable label is defined in
	the current space.
 */

static int
pa_label_is_defined ()
{
  return (int) pa_get_label ();
}

/*
	PA_DEFINE_LABEL

	Defines a label for the current space.  If one is already defined,
	this function will replace it with the new label.
 */

void
pa_define_label (symbolP)
     symbolS *symbolP;
{
  label_symbolS *lssP = pa_get_label ();
  space_dict_chainS *now_sdcP = pa_segment_to_space (now_seg);

  if (lssP)
    {
      lssP->lss_label = symbolP;
    }
  else
    {
      lssP = (label_symbolS *) xmalloc (sizeof (label_symbolS));
      lssP->lss_label = symbolP;
      lssP->lss_space = now_sdcP;
      lssP->lss_next = (label_symbolS *) NULL;

      if (label_symbols_rootP)
	{
	  lssP->lss_next = label_symbols_rootP;
	}
      label_symbols_rootP = lssP;
    }
}

/*
	PA_UNDEFINE_LABEL

	Removes a label definition for the current space.
	If there is no label_symbolS entry, then no action is taken.
 */

static void
pa_undefine_label ()
{
  label_symbolS *lssP;
  label_symbolS *prevP = (label_symbolS *) NULL;
  space_dict_chainS *now_sdcP = pa_segment_to_space (now_seg);

  for (lssP = label_symbols_rootP; lssP; lssP = lssP->lss_next)
    {
      if (now_sdcP == lssP->lss_space && lssP->lss_label)
	{
	  if (prevP)
	    prevP->lss_next = lssP->lss_next;
	  else
	    label_symbols_rootP = lssP->lss_next;

	  free (lssP);
	  break;
	}
      prevP = lssP;
    }
}

/* end of label symbol support. */


/* An HPPA-specific version of fix_new.  This is required because the HPPA
   code needs to keep track of some extra stuff.  Each call to fix_new_hppa
   results in the creation of an instance of an hppa_fixS.  An hppa_fixS
   stores the extra information along with a pointer to the original fixS.  */

typedef struct hppa_fix_struct
  {
    fixS *fx_fixP;
    int fx_r_field;
    int fx_r_type;
    int fx_r_format;
    long fx_arg_reloc;
    call_infoS *fx_call_infop;
    char fx_unwind[8];
    struct hppa_fix_struct *fx_next;
  } hppa_fixS;

static hppa_fixS *hppa_fix_root;

void 
fix_new_hppa (frag, where, size, add_symbol, offset, exp, pcrel,
	      r_type, r_field, r_format, arg_reloc, unwind_desc)
     fragS *frag;		/* Which frag? */
     int where;			/* Where in that frag? */
     short int size;		/* 1, 2  or 4 usually. */
     symbolS *add_symbol;	/* X_add_symbol. */
     long offset;		/* X_add_number. */
     expressionS *exp;		/* expression (if non-null) */
     int pcrel;			/* TRUE if PC-relative relocation. */
#ifdef BFD_ASSEMBLER
     bfd_reloc_code_real_type r_type;	/* Relocation type */
#else
     int r_type;		/* Relocation type */
#endif
     long r_field;		/* F, R, L, etc */
     int r_format;		/* 11,12,14,17,21,32, etc */
     long arg_reloc;
     char *unwind_desc;
{
  fixS *new_fix;

  hppa_fixS *hppa_fix = (hppa_fixS *) obstack_alloc (&notes, sizeof (hppa_fixS));

  if (exp != NULL)
    new_fix = fix_new_exp (frag, where, size, exp, pcrel, r_type);
  else
    new_fix = fix_new (frag, where, size, add_symbol, offset, pcrel, r_type);
  hppa_fix->fx_fixP = new_fix;
  hppa_fix->fx_r_field = r_field;
  hppa_fix->fx_r_format = r_format;
  hppa_fix->fx_arg_reloc = arg_reloc;
  hppa_fix->fx_next = (hppa_fixS *) 0;
  hppa_fix->fx_call_infop = last_call_info;
  if (unwind_desc)
    bcopy (unwind_desc, hppa_fix->fx_unwind, 8);

  if (hppa_fix_root)
    hppa_fix->fx_next = hppa_fix_root;

  hppa_fix_root = hppa_fix;

  /* SKV 12/22/92.  Added prev_insn, prev_fix, and initialized the_insn
   so that we can recognize instruction sequences such as (ldil, ble)
   and generate the appropriate fixups. */

#ifdef OBJ_ELF

  curr_fix = new_fix;

#endif /* OBJ_ELF */
}

/* Parse a .byte, .word, .long expression for the HPPA.  Called by
   cons via the TC_PARSE_CONS_EXPRESSION macro.  */

static int hppa_field_selector;

void
parse_cons_expression_hppa (exp)
     expressionS *exp;
{
  hppa_field_selector = pa_chk_field_selector (&input_line_pointer);
  expression (exp);
}

/* This fix_new is called by cons via TC_CONS_FIX_NEW.
   hppa_field_selector is set by the parse_cons_expression_hppa.  */

void
cons_fix_new_hppa (frag, where, size, exp)
     fragS *frag;		/* Which frag? */
     int where;			/* Where in that frag? */
     int size;			/* 1, 2  or 4 usually. */
     expressionS *exp;		/* Expression. */
{
  unsigned int reloc_type;

  if (is_DP_relative (*exp))
    reloc_type = R_HPPA_GOTOFF;
  else if (is_complex (*exp))
    reloc_type = R_HPPA_COMPLEX;
  else
    reloc_type = R_HPPA;

  if (hppa_field_selector != e_psel && hppa_field_selector != e_fsel)
    as_warn("Invalid field selector.  Assuming F%%.");

  fix_new_hppa (frag, where, size,
		(symbolS *) NULL, (offsetT) 0, exp, 0, reloc_type,
		hppa_field_selector, 32, 0, (char *) 0);
}

/* Given a FixS, find the hppa_fixS associated with it. */
hppa_fixS *
hppa_find_hppa_fix (fix)
     fixS *fix;
{
  hppa_fixS *hfP;

  for (hfP = hppa_fix_root; hfP; hfP = hfP->fx_next)
    {
      if (hfP->fx_fixP == fix)
	return hfP;
    }

  return (hppa_fixS *) 0;
}

/* This function is called once, at assembler startup time.  It should
   set up all the tables, etc. that the MD part of the assembler will need.  */
void
md_begin ()
{
  register char *retval = NULL;
  int lose = 0;
  register unsigned int i = 0;
  void pa_spaces_begin ();	/* forward declaration */

  last_call_info = NULL;
  call_info_root = NULL;

  pa_spaces_begin ();

  op_hash = hash_new ();
  if (op_hash == NULL)
    as_fatal ("Virtual memory exhausted");

  while (i < NUMOPCODES)
    {
      const char *name = pa_opcodes[i].name;
      retval = hash_insert (op_hash, name, &pa_opcodes[i]);
      if (retval != NULL)
	{
	  as_fatal ("Internal error: can't hash `%s': %s\n",
		    pa_opcodes[i].name, retval);
	  lose = 1;
	}
      do
	{
	  if ((pa_opcodes[i].match & pa_opcodes[i].mask) != pa_opcodes[i].match)
	    {
	      fprintf (stderr, "internal error: losing opcode: `%s' \"%s\"\n",
		       pa_opcodes[i].name, pa_opcodes[i].args);
	      lose = 1;
	    }
	  ++i;
	}
      while (i < NUMOPCODES
	     && !strcmp (pa_opcodes[i].name, name));
    }

  if (lose)
    as_fatal ("Broken assembler.  No assembly attempted.");

  for (i = '0'; i < '8'; ++i)
    octal[i] = 1;
  for (i = '0'; i <= '9'; ++i)
    toHex[i] = i - '0';
  for (i = 'a'; i <= 'f'; ++i)
    toHex[i] = i + 10 - 'a';
  for (i = 'A'; i <= 'F'; ++i)
    toHex[i] = i + 10 - 'A';

}

void
md_end ()
{
  return;
}

void
md_assemble (str)
     char *str;
{
  char *toP;

  assert (str);
  pa_ip (str);
  toP = frag_more (4);
  /* put out the opcode */
  md_number_to_chars (toP, the_insn.opcode, 4);

  /* put out the symbol-dependent stuff */
#if defined ( OBJ_SOM )
  if (the_insn.reloc != R_NO_RELOCATION)
    {
#else
#if defined ( OBJ_ELF )
  if (the_insn.reloc != R_HPPA_NONE)
    {
#endif
#endif

#if defined(OBJ_ELF)
      fix_new_hppa (frag_now,	/* which frag */
		    (toP - frag_now->fr_literal),	/* where */
		    4,		/* size */
		    (symbolS *) NULL,
		    (offsetT) 0,
		    &the_insn.exp,
		    the_insn.pcrel,
		    the_insn.reloc,
		    the_insn.field_selector,
		    the_insn.format,
		    the_insn.arg_reloc,
		    (char *) 0);
#endif
#ifdef OBJ_SOM
      fix_new (frag_now,	/* which frag */
	       (toP - frag_now->fr_literal),	/* where */
	       4,		/* size */
	       (symbolS *) NULL,
	       (offsetT) 0,
	       &the_insn.exp,
	       the_insn.pcrel,
	       the_insn.reloc,
	       the_insn.field_selector,
	       the_insn.code,
	       the_insn.arg_reloc,
	       (char *) 0);
#endif
    }

  /* SKV 12/22/92.  Added prev_insn, prev_fix, and initialized the_insn
   so that we can recognize instruction sequences such as (ldil, ble)
   and generate the appropriate fixups. */

#ifdef OBJ_ELF

  prev_insn = the_insn;
  strncpy (prev_str, str, 10);
  if (prev_insn.reloc == R_HPPA_NONE)
    {
      prev_fix = NULL;
    }
  else
    {
      prev_fix = curr_fix;
    }

#endif /* OBJ_ELF */
}

static void
pa_ip (str)
     char *str;
{
  char *error_message = "";
  char *s;
  const char *args;
  char c;
  unsigned long i;
  struct pa_opcode *insn;
  char *argsStart;
  unsigned long opcode;
  int match = FALSE;
  int comma = 0;
  int reg, s2, s3;
  unsigned int im21, im14, im11, im5;
  int m, a, uu, f;
  int cmpltr, nullif, flag;
  int sfu, cond;
  char *name;
  char *save_s;

#ifdef PA_DEBUG
  fprintf (stderr, "STATEMENT: \"%s\"\n", str);
#endif
  for (s = str; isupper (*s) || islower (*s) || (*s >= '0' && *s <= '3'); ++s)
    ;
  switch (*s)
    {

    case '\0':
      break;

    case ',':
      comma = 1;

      /*FALLTHROUGH*/

    case ' ':
      *s++ = '\0';
      break;

    default:
      as_bad ("Unknown opcode: `%s'", str);
      exit (1);
    }

  save_s = str;

  while (*save_s)
    {
      if (isupper (*save_s))
	*save_s = tolower (*save_s);
      save_s++;
    }

  if ((insn = (struct pa_opcode *) hash_find (op_hash, str)) == NULL)
    {
      as_bad ("Unknown opcode: `%s'", str);
      return;
    }
  if (comma)
    {
      *--s = ',';
    }
  argsStart = s;
  for (;;)
    {
      opcode = insn->match;
      bzero (&the_insn, sizeof (the_insn));
#if defined( OBJ_SOM )
      the_insn.reloc = R_NO_RELOCATION;
#else
#if defined ( OBJ_ELF )
      the_insn.reloc = R_HPPA_NONE;
#endif
#endif
      /*
	 * Build the opcode, checking as we go to make
	 * sure that the operands match
	 */
      for (args = insn->args;; ++args)
	{

	  switch (*args)
	    {

	    case '\0':		/* end of args */
	      if (*s == '\0')
		{
		  match = TRUE;
		}
	      break;

	    case '+':
	      if (*s == '+')
		{
		  ++s;
		  continue;
		}
	      if (*s == '-')
		{
		  continue;
		}
	      break;

	    case '(':		/* these must match exactly */
	    case ')':
	    case ',':
	    case ' ':
	      if (*s++ == *args)
		continue;
	      break;

	    case 'b':		/* 5 bit register field at 10 */
	    case '^':		/* 5 bit control register field at 10 */
	      reg = pa_parse_number (&s);
	      if (reg < 32 && reg >= 0)
		{
		  opcode |= reg << 21;
		  continue;
		}
	      break;
	    case 'x':		/* 5 bit register field at 15 */
	      reg = pa_parse_number (&s);
	      if (reg < 32 && reg >= 0)
		{
		  opcode |= reg << 16;
		  continue;
		}
	      break;

	    case 'y':		/* Same as 't'.  */
	    case 't':		/* 5 bit register field at 31 */
	      reg = pa_parse_number (&s);
	      if (reg < 32 && reg >= 0)
		{
		  opcode |= reg;
		  continue;
		}
	      break;
	    case 'T':		/* 5 bit field length at 31 (encoded as 32-T) */
	      /*
		reg = pa_parse_number(&s);
	       */
	      getAbsoluteExpression (s);
	      if (the_insn.exp.X_op == O_constant)
		{
		  reg = the_insn.exp.X_add_number;
		  if (reg <= 32 && reg > 0)
		    {
		      opcode |= 32 - reg;
		      s = expr_end;
		      continue;
		    }
		}
	      break;
	    case '5':		/* 5 bit immediate at 15 */
	      getAbsoluteExpression (s);
	      /** PJH: The following 2 calls to as_bad() might eventually **/
	      /**      want to end up as as_warn().  **/
	      if (the_insn.exp.X_add_number > 15)
		{
		  as_bad ("5 bit immediate > 15. Set to 15",
			  the_insn.exp.X_add_number);
		  the_insn.exp.X_add_number = 15;
		}
	      else if (the_insn.exp.X_add_number < -16)
		{
		  as_bad ("5 bit immediate < -16. Set to -16",
			  the_insn.exp.X_add_number);
		  the_insn.exp.X_add_number = -16;
		}

	      low_sign_unext (evaluateAbsolute (the_insn.exp, the_insn.field_selector),
			      5, &im5);
	      opcode |= (im5 << 16);
	      s = expr_end;
	      continue;

	    case 's':		/* 2 bit space identifier at 17 */
	      s2 = pa_parse_number (&s);
	      if (s2 < 4 && s2 >= 0)
		{
		  opcode |= s2 << 14;
		  continue;
		}
	      break;
	    case 'S':		/* 3 bit space identifier at 18 */
	      s3 = pa_parse_number (&s);
	      if (s3 < 8 && s3 >= 0)
		{
		  dis_assemble_3 (s3, &s3);
		  opcode |= s3 << 13;
		  continue;
		}
	      break;
	    case 'c':		/* indexed load completer. */
	      uu = 0;
	      m = 0;
	      i = 0;
	      while (*s == ',' && i < 2)
		{
		  s++;
		  if (strncasecmp (s, "sm", 2) == 0)
		    {
		      uu = 1;
		      m = 1;
		      s++;
		      i++;
		    }
		  else if (strncasecmp (s, "m", 1) == 0)
		    m = 1;
		  else if (strncasecmp (s, "s", 1) == 0)
		    uu = 1;
		  else
		    as_bad ("Unrecognized Indexed Load Completer...assuming 0");
		  s++;
		  i++;
		}
	      if (i > 2)
		as_bad ("Illegal Indexed Load Completer Syntax...extras ignored");
	      /* pa_skip(&s); */
	      while (*s == ' ' || *s == '\t')
		s++;

	      opcode |= m << 5;
	      opcode |= uu << 13;
	      continue;
	    case 'C':		/* short load and store completer */
	      a = 0;
	      m = 0;
	      if (*s == ',')
		{
		  s++;
		  if (strncasecmp (s, "ma", 2) == 0)
		    {
		      a = 0;
		      m = 1;
		    }
		  else if (strncasecmp (s, "mb", 2) == 0)
		    {
		      a = 1;
		      m = 1;
		    }
		  else
		    as_bad ("Unrecognized Indexed Load Completer...assuming 0");
		  s += 2;
		}
	      /* pa_skip(&s); */
	      while (*s == ' ' || *s == '\t')
		s++;
	      opcode |= m << 5;
	      opcode |= a << 13;
	      continue;
	    case 'Y':		/* Store Bytes Short completer */
	      a = 0;
	      m = 0;
	      i = 0;
	      while (*s == ',' && i < 2)
		{
		  s++;
		  if (strncasecmp (s, "m", 1) == 0)
		    m = 1;
		  else if (strncasecmp (s, "b", 1) == 0)
		    a = 0;
		  else if (strncasecmp (s, "e", 1) == 0)
		    a = 1;
		  else
		    as_bad ("Unrecognized Store Bytes Short Completer...assuming 0");
		  s++;
		  i++;
		}
	      /**		if ( i >= 2 ) **/
	      if (i > 2)
		as_bad ("Illegal Store Bytes Short Completer...extras ignored");
	      while (*s == ' ' || *s == '\t')	/* skip to next operand */
		s++;
	      opcode |= m << 5;
	      opcode |= a << 13;
	      continue;
	    case '<':		/* non-negated compare/subtract conditions. */
	      cmpltr = pa_parse_nonneg_cmpsub_cmpltr (&s, 1);
	      if (cmpltr < 0)
		{
		  as_bad ("Unrecognized Compare/Subtract Condition: %c", *s);
		  cmpltr = 0;
		}
	      opcode |= cmpltr << 13;
	      continue;
	    case '?':		/* negated or non-negated cmp/sub conditions. */
	      /* used only by ``comb'' and ``comib'' pseudo-ops */
	      save_s = s;
	      cmpltr = pa_parse_nonneg_cmpsub_cmpltr (&s, 1);
	      if (cmpltr < 0)
		{
		  s = save_s;
		  cmpltr = pa_parse_neg_cmpsub_cmpltr (&s, 1);
		  if (cmpltr < 0)
		    {
		      as_bad ("Unrecognized Compare/Subtract Condition: %c", *s);
		      cmpltr = 0;
		    }
		  else
		    {
		      opcode |= 1 << 27;	/* required opcode change to make
		                        COMIBT into a COMIBF or a
		                        COMBT into a COMBF or a
			                ADDBT into a ADDBF or a
			                ADDIBT into a ADDIBF */
		    }
		}
	      opcode |= cmpltr << 13;
	      continue;
	    case '!':		/* negated or non-negated add conditions. */
	      /* used only by ``addb'' and ``addib'' pseudo-ops */
	      save_s = s;
	      cmpltr = pa_parse_nonneg_add_cmpltr (&s, 1);
	      if (cmpltr < 0)
		{
		  s = save_s;
		  cmpltr = pa_parse_neg_add_cmpltr (&s, 1);
		  if (cmpltr < 0)
		    {
		      as_bad ("Unrecognized Compare/Subtract Condition: %c", *s);
		      cmpltr = 0;
		    }
		  else
		    {
		      opcode |= 1 << 27; /* required opcode change to make
					    COMIBT into a COMIBF or a
					    COMBT into a COMBF or a
					    ADDBT into a ADDBF or a
					    ADDIBT into a ADDIBF */
		    }
		}
	      opcode |= cmpltr << 13;
	      continue;
	    case 'a':		/* compare/subtract conditions */
	      cmpltr = 0;
	      f = 0;
	      save_s = s;
	      if (*s == ',')
		{
		  cmpltr = pa_parse_nonneg_cmpsub_cmpltr (&s, 0);
		  if (cmpltr < 0)
		    {
		      f = 1;
		      s = save_s;
		      cmpltr = pa_parse_neg_cmpsub_cmpltr (&s, 0);
		      if (cmpltr < 0)
			{
			  as_bad ("Unrecognized Compare/Subtract Condition");
			}
		    }
		}
	      opcode |= cmpltr << 13;
	      opcode |= f << 12;
	      continue;
	    case 'd':		/* non-negated add conditions */
	      cmpltr = 0;
	      nullif = 0;
	      flag = 0;
	      if (*s == ',')
		{
		  s++;
		  name = s;
		  while (*s != ',' && *s != ' ' && *s != '\t')
		    s += 1;
		  c = *s;
		  *s = 0x00;
		  if (strcmp (name, "=") == 0)
		    {
		      cmpltr = 1;
		    }
		  else if (strcmp (name, "<") == 0)
		    {
		      cmpltr = 2;
		    }
		  else if (strcmp (name, "<=") == 0)
		    {
		      cmpltr = 3;
		    }
		  else if (strcasecmp (name, "nuv") == 0)
		    {
		      cmpltr = 4;
		    }
		  else if (strcasecmp (name, "znv") == 0)
		    {
		      cmpltr = 5;
		    }
		  else if (strcasecmp (name, "sv") == 0)
		    {
		      cmpltr = 6;
		    }
		  else if (strcasecmp (name, "od") == 0)
		    {
		      cmpltr = 7;
		    }
		  else if (strcasecmp (name, "n") == 0)
		    {
		      nullif = 1;
		    }
		  else if (strcasecmp (name, "tr") == 0)
		    {
		      cmpltr = 0;
		      flag = 1;
		    }
		  else if (strcasecmp (name, "<>") == 0)
		    {
		      cmpltr = 1;
		      flag = 1;
		    }
		  else if (strcasecmp (name, ">=") == 0)
		    {
		      cmpltr = 2;
		      flag = 1;
		    }
		  else if (strcasecmp (name, ">") == 0)
		    {
		      cmpltr = 3;
		      flag = 1;
		    }
		  else if (strcasecmp (name, "uv") == 0)
		    {
		      cmpltr = 4;
		      flag = 1;
		    }
		  else if (strcasecmp (name, "vnz") == 0)
		    {
		      cmpltr = 5;
		      flag = 1;
		    }
		  else if (strcasecmp (name, "nsv") == 0)
		    {
		      cmpltr = 6;
		      flag = 1;
		    }
		  else if (strcasecmp (name, "ev") == 0)
		    {
		      cmpltr = 7;
		      flag = 1;
		    }
		  else
		    as_bad ("Unrecognized Add Condition: %s", name);
		  *s = c;
		}
	      nullif = pa_parse_nullif (&s);
	      opcode |= nullif << 1;
	      opcode |= cmpltr << 13;
	      opcode |= flag << 12;
	      continue;
	    case '&':		/* logical instruction conditions */
	      cmpltr = 0;
	      f = 0;
	      if (*s == ',')
		{
		  s++;
		  name = s;
		  while (*s != ',' && *s != ' ' && *s != '\t')
		    s += 1;
		  c = *s;
		  *s = 0x00;
		  if (strcmp (name, "=") == 0)
		    {
		      cmpltr = 1;
		    }
		  else if (strcmp (name, "<") == 0)
		    {
		      cmpltr = 2;
		    }
		  else if (strcmp (name, "<=") == 0)
		    {
		      cmpltr = 3;
		    }
		  else if (strcasecmp (name, "od") == 0)
		    {
		      cmpltr = 7;
		    }
		  else if (strcasecmp (name, "tr") == 0)
		    {
		      cmpltr = 0;
		      f = 1;
		    }
		  else if (strcmp (name, "<>") == 0)
		    {
		      cmpltr = 1;
		      f = 1;
		    }
		  else if (strcmp (name, ">=") == 0)
		    {
		      cmpltr = 2;
		      f = 1;
		    }
		  else if (strcmp (name, ">") == 0)
		    {
		      cmpltr = 3;
		      f = 1;
		    }
		  else if (strcasecmp (name, "ev") == 0)
		    {
		      cmpltr = 7;
		      f = 1;
		    }
		  else
		    as_bad ("Unrecognized Logical Instruction Condition: %s", name);
		  *s = c;
		}
	      opcode |= cmpltr << 13;
	      opcode |= f << 12;
	      continue;
	    case 'U':		/* unit instruction conditions */
	      cmpltr = 0;
	      f = 0;
	      if (*s == ',')
		{
		  s++;
		  if (strncasecmp (s, "sbz", 3) == 0)
		    {
		      cmpltr = 2;
		      s += 3;
		    }
		  else if (strncasecmp (s, "shz", 3) == 0)
		    {
		      cmpltr = 3;
		      s += 3;
		    }
		  else if (strncasecmp (s, "sdc", 3) == 0)
		    {
		      cmpltr = 4;
		      s += 3;
		    }
		  else if (strncasecmp (s, "sbc", 3) == 0)
		    {
		      cmpltr = 6;
		      s += 3;
		    }
		  else if (strncasecmp (s, "shc", 3) == 0)
		    {
		      cmpltr = 7;
		      s += 3;
		    }
		  else if (strncasecmp (s, "tr", 2) == 0)
		    {
		      cmpltr = 0;
		      f = 1;
		      s += 2;
		    }
		  else if (strncasecmp (s, "nbz", 3) == 0)
		    {
		      cmpltr = 2;
		      f = 1;
		      s += 3;
		    }
		  else if (strncasecmp (s, "nhz", 3) == 0)
		    {
		      cmpltr = 3;
		      f = 1;
		      s += 3;
		    }
		  else if (strncasecmp (s, "ndc", 3) == 0)
		    {
		      cmpltr = 4;
		      f = 1;
		      s += 3;
		    }
		  else if (strncasecmp (s, "nbc", 3) == 0)
		    {
		      cmpltr = 6;
		      f = 1;
		      s += 3;
		    }
		  else if (strncasecmp (s, "nhc", 3) == 0)
		    {
		      cmpltr = 7;
		      f = 1;
		      s += 3;
		    }
		  else
		    as_bad ("Unrecognized Logical Instruction Condition: %c", *s);
		}
	      opcode |= cmpltr << 13;
	      opcode |= f << 12;
	      continue;
	    case '|':		/* shift/extract/deposit in conditional.  */
	    case '>':		/* shift/extract/deposit conditions. */
	      cmpltr = 0;
	      if (*s == ',')
		{
		  char *save_s = s++;
		  name = s;
		  while (*s != ',' && *s != ' ' && *s != '\t')
		    s += 1;
		  c = *s;
		  *s = 0x00;
		  if (strcmp (name, "=") == 0)
		    {
		      cmpltr = 1;
		    }
		  else if (strcmp (name, "<") == 0)
		    {
		      cmpltr = 2;
		    }
		  else if (strcasecmp (name, "od") == 0)
		    {
		      cmpltr = 3;
		    }
		  else if (strcasecmp (name, "tr") == 0)
		    {
		      cmpltr = 4;
		    }
		  else if (strcmp (name, "<>") == 0)
		    {
		      cmpltr = 5;
		    }
		  else if (strcmp (name, ">=") == 0)
		    {
		      cmpltr = 6;
		    }
		  else if (strcasecmp (name, "ev") == 0)
		    {
		      cmpltr = 7;
		    }
		  /* Handle movb,n.  Put things back the way they were.  
		     This includes moving s back to where it started.  */
		  else if (strcasecmp (name, "n") == 0 && *args == '|')
		    {
		      *s = c;
		      s = save_s;
		      continue;
		    }
		  else
		    as_bad ("Unrecognized Shift/Extract/Deposit Condition: %s", name);
		  *s = c;
		}
	      opcode |= cmpltr << 13;
	      continue;
	    case '~':		/* bvb,bb conditions */
	      cmpltr = 0;
	      if (*s == ',')
		{
		  s++;
		  if (strncmp (s, "<", 1) == 0)
		    {
		      cmpltr = 2;
		      s++;
		    }
		  else if (strncmp (s, ">=", 2) == 0)
		    {
		      cmpltr = 6;
		      s += 2;
		    }
		  else
		    as_bad ("Unrecognized Bit Branch Condition: %c", *s);
		}
	      opcode |= cmpltr << 13;
	      continue;
	    case 'V':		/* 5  bit immediate at 31 */
	      getExpression (s);
	      low_sign_unext (evaluateAbsolute (the_insn.exp, the_insn.field_selector),
			      5, &im5);
	      opcode |= im5;
	      s = expr_end;
	      continue;
	    case 'r':		/* 5  bit immediate at 31 */
	      /* (unsigned value for the break instruction) */
	      getExpression (s);
	      im5 = evaluateAbsolute (the_insn.exp, the_insn.field_selector);
	      if (im5 > 31)
		{
		  as_bad ("Operand out of range. Was: %d. Should be [0..31]. Assuming %d.\n", im5, im5 & 0x1f);
		  im5 = im5 & 0x1f;
		}
	      opcode |= im5;
	      s = expr_end;
	      continue;
	    case 'R':		/* 5  bit immediate at 15 */
	      /* (unsigned value for the ssm and rsm instruction) */
	      getExpression (s);
	      im5 = evaluateAbsolute (the_insn.exp, the_insn.field_selector);
	      if (im5 > 31)
		{
		  as_bad ("Operand out of range. Was: %d. Should be [0..31]. Assuming %d.\n", im5, im5 & 0x1f);
		  im5 = im5 & 0x1f;
		}
	      opcode |= im5 << 16;
	      s = expr_end;
	      continue;
	    case 'i':		/* 11 bit immediate at 31 */
#ifdef OBJ_SOM
	      getExpression (s);
	      if (the_insn.exp.X_op == O_constant)
		{
		  low_sign_unext (evaluateAbsolute (the_insn.exp, the_insn.field_selector),
				  11, &im11);
		  opcode |= im11;
		}
	      else
		{
		  the_insn.reloc = R_CODE_ONE_SYMBOL;
		  the_insn.code = 'i';
		  the_insn.field_selector = the_insn.exp.field_selector;
		}
	      s = expr_end;
	      continue;
#else
	      the_insn.field_selector = pa_chk_field_selector (&s);
	      getExpression (s);
	      if (the_insn.exp.X_op == O_constant)
		{
		  low_sign_unext (evaluateAbsolute (the_insn.exp, the_insn.field_selector),
				  11, &im11);
		  opcode |= im11;
		}
	      else
		{
		  if (is_DP_relative (the_insn.exp))
		    the_insn.reloc = R_HPPA_GOTOFF;
		  else if (is_PC_relative (the_insn.exp))
		    the_insn.reloc = R_HPPA_PCREL_CALL;
		  else if (is_complex (the_insn.exp))
		    the_insn.reloc = R_HPPA_COMPLEX;
		  else
		    the_insn.reloc = R_HPPA;
		  the_insn.format = 11;
		}
	      s = expr_end;
	      continue;
#endif
	    case 'j':		/* 14 bit immediate at 31 */
#ifdef OBJ_SOM
	      getExpression (s);
	      if (the_insn.exp.X_op == O_constant)
		{
		  low_sign_unext (evaluateAbsolute (the_insn.exp, field_selector),
				  14, &im14);
		  if (the_insn.exp.field_selector == e_rsel)
		    opcode |= (im14 & 0xfff);
		  else
		    opcode |= im14;
		}
	      else
		{
		  the_insn.reloc = R_CODE_ONE_SYMBOL;
		  the_insn.code = 'j';
		  the_insn.field_selector = the_insn.exp.field_selector;
		}
	      s = expr_end;
	      continue;
#else
	      the_insn.field_selector = pa_chk_field_selector (&s);
	      getExpression (s);
	      if (the_insn.exp.X_op == O_constant)
		{
		  low_sign_unext (evaluateAbsolute (the_insn.exp, the_insn.field_selector),
				  14, &im14);
		  if (the_insn.field_selector == e_rsel)
		    opcode |= (im14 & 0xfff);
		  else
		    opcode |= im14;
		}
	      else
		{
		  if (is_DP_relative (the_insn.exp))
		    the_insn.reloc = R_HPPA_GOTOFF;
		  else if (is_PC_relative (the_insn.exp))
		    the_insn.reloc = R_HPPA_PCREL_CALL;
		  else if (is_complex (the_insn.exp))
		    the_insn.reloc = R_HPPA_COMPLEX;
		  else
		    the_insn.reloc = R_HPPA;
		  the_insn.format = 14;
		}
	      s = expr_end;
	      continue;
#endif

	    case 'k':		/* 21 bit immediate at 31 */
#ifdef OBJ_SOM
	      getExpression (s);
	      if (the_insn.exp.X_op == O_constant)
		{
		  dis_assemble_21 (evaluateAbsolute (the_insn.exp, the_insn.field_selector),
				   &im21);
		  opcode |= im21;
		}
	      else
		{
		  the_insn.reloc = R_CODE_ONE_SYMBOL;
		  the_insn.code = 'k';
		  the_insn.field_selector = the_insn.exp.field_selector;
		}
	      s = expr_end;
	      continue;
#else
	      the_insn.field_selector = pa_chk_field_selector (&s);
	      getExpression (s);
	      if (the_insn.exp.X_op == O_constant)
		{
		  dis_assemble_21 (evaluateAbsolute (the_insn.exp, the_insn.field_selector),
				   &im21);
		  opcode |= im21;
		}
	      else
		{
		  if (is_DP_relative (the_insn.exp))
		    the_insn.reloc = R_HPPA_GOTOFF;
		  else if (is_PC_relative (the_insn.exp))
		    the_insn.reloc = R_HPPA_PCREL_CALL;
		  else if (is_complex (the_insn.exp))
		    the_insn.reloc = R_HPPA_COMPLEX;
		  else
		    the_insn.reloc = R_HPPA;
		  the_insn.format = 21;
		}
	      s = expr_end;
	      continue;
#endif

	    case 'n':		/* nullification for branch instructions */
	      nullif = pa_parse_nullif (&s);
	      opcode |= nullif << 1;
	      continue;
	    case 'w':		/* 12 bit branch displacement */
#ifdef OBJ_SOM
	      getExpression (s);
	      the_insn.pcrel = 1;
	      if (strcmp (the_insn.exp.X_add_symbol->sy_nlist.n_un.n_name, "L0\001") == 0)
		{
		  unsigned int w1, w, result;

		  sign_unext ((the_insn.exp.X_add_number - 8) >> 2, 12, &result);
		  dis_assemble_12 (result, &w1, &w);
		  opcode |= ((w1 << 2) | w);
		  the_insn.exp.X_add_symbol->sy_ref = FALSE;
		}
	      else
		{
		  /* this has to be wrong -- dont know what is right! */
		  the_insn.reloc = R_PCREL_CALL;
		  the_insn.code = 'w';
		  the_insn.field_selector = the_insn.exp.field_selector;
		  the_insn.arg_reloc = last_call_desc.arg_reloc;
		  bzero (&last_call_desc, sizeof (call_descS));
		}
	      s = expr_end;
	      continue;
#else
	      the_insn.field_selector = pa_chk_field_selector (&s);
	      getExpression (s);
	      the_insn.pcrel = 1;
	      if (strcmp (S_GET_NAME (the_insn.exp.X_add_symbol), "L0\001") == 0)
		{
		  unsigned int w1, w, result;

		  sign_unext ((the_insn.exp.X_add_number - 8) >> 2, 12, &result);
		  dis_assemble_12 (result, &w1, &w);
		  opcode |= ((w1 << 2) | w);
		  /* the_insn.exp.X_add_symbol->sy_ref = FALSE; *//* XXX: not sure how to do this in BFD */
		}
	      else
		{
		  if (is_complex (the_insn.exp))
		    the_insn.reloc = R_HPPA_COMPLEX_PCREL_CALL;
		  else
		    the_insn.reloc = R_HPPA_PCREL_CALL;
		  the_insn.format = 12;
		  the_insn.arg_reloc = last_call_desc.arg_reloc;
		  bzero (&last_call_desc, sizeof (call_descS));
		}
	      s = expr_end;
	      continue;
#endif
	    case 'W':		/* 17 bit branch displacement */
#if defined(OBJ_ELF)
	      the_insn.field_selector = pa_chk_field_selector (&s);
#endif
	      getExpression (s);
	      the_insn.pcrel = 1;
#ifdef OBJ_SOM
	      if (strcmp (the_insn.exp.X_add_symbol->sy_nlist.n_un.n_name, "L0\001") == 0)
		{
		  unsigned int w2, w1, w, result;

		  sign_unext ((the_insn.exp.X_add_number - 8) >> 2, 17, &result);
		  dis_assemble_17 (result, &w1, &w2, &w);
		  opcode |= ((w2 << 2) | (w1 << 16) | w);
		  the_insn.exp.X_add_symbol->sy_ref = FALSE;
		}
	      else
		{
		  /* this has to be wrong -- dont know what is right! */
		  the_insn.reloc = R_PCREL_CALL;
		  the_insn.code = 'W';
		  the_insn.field_selector = the_insn.exp.field_selector;
		  the_insn.arg_reloc = last_call_desc.arg_reloc;
		  bzero (&last_call_desc, sizeof (call_descS));
		}
#else
	      if (the_insn.exp.X_add_symbol)
		{
		  if (strcmp (S_GET_NAME (the_insn.exp.X_add_symbol), "L0\001") == 0)
		    {
		      unsigned int w2, w1, w, result;

		      sign_unext ((the_insn.exp.X_add_number - 8) >> 2, 17, &result);
		      dis_assemble_17 (result, &w1, &w2, &w);
		      opcode |= ((w2 << 2) | (w1 << 16) | w);
		    }
		  else
		    {
		      if (is_complex (the_insn.exp))
			the_insn.reloc = R_HPPA_COMPLEX_PCREL_CALL;
		      else
			the_insn.reloc = R_HPPA_PCREL_CALL;
		      the_insn.format = 17;
		      the_insn.arg_reloc = last_call_desc.arg_reloc;
		      bzero (&last_call_desc, sizeof (call_descS));
		    }
		}
	      else
		{
		  unsigned int w2, w1, w, result;

		  sign_unext (the_insn.exp.X_add_number >> 2, 17, &result);
		  dis_assemble_17 (result, &w1, &w2, &w);
		  opcode |= ((w2 << 2) | (w1 << 16) | w);
		}
#endif
	      s = expr_end;
	      continue;
	    case 'z':		/* 17 bit branch displacement (not pc-relative) */
#if defined(OBJ_ELF)
	      the_insn.field_selector = pa_chk_field_selector (&s);
#endif
	      getExpression (s);
	      the_insn.pcrel = 0;
#ifdef OBJ_SOM
	      if (strcmp (the_insn.exp.X_add_symbol->sy_nlist.n_un.n_name, "L0\001") == 0)
		{
		  unsigned int w2, w1, w, result;

		  sign_unext ((the_insn.exp.X_add_number - 8) >> 2, 17, &result);
		  dis_assemble_17 (result, &w1, &w2, &w);
		  opcode |= ((w2 << 2) | (w1 << 16) | w);
		  the_insn.exp.X_add_symbol->sy_ref = FALSE;
		}
	      else
		{
		  /* this has to be wrong -- dont know what is right! */
		  the_insn.reloc = R_PCREL_CALL;
		  the_insn.code = 'W';
		  the_insn.field_selector = the_insn.exp.field_selector;
		  the_insn.arg_reloc = last_call_desc.arg_reloc;
		  bzero (&last_call_desc, sizeof (call_descS));
		}
#else
	      if (the_insn.exp.X_add_symbol)
		{
		  if (strcmp (S_GET_NAME (the_insn.exp.X_add_symbol), "L0\001") == 0)
		    {
		      unsigned int w2, w1, w, result;

		      sign_unext ((the_insn.exp.X_add_number - 8) >> 2, 17, &result);
		      dis_assemble_17 (result, &w1, &w2, &w);
		      opcode |= ((w2 << 2) | (w1 << 16) | w);
		    }
		  else
		    {
		      if (is_complex (the_insn.exp))
			{
			  the_insn.reloc = R_HPPA_COMPLEX_ABS_CALL;
			}
		      else
			{
			  the_insn.reloc = R_HPPA_ABS_CALL;
			}
		      /* This could also be part of an instruction sequence of
				 interest.  If so, check to make sure that the previous
				 instruction's fixup is appropriate.  (ble, be instructions
                                 affect the reloc of immediately preceding ldil
                                 instructions.) */
		      if (strcasecmp (prev_str, "ldil") == 0 &&
			  prev_insn.exp.X_add_symbol == the_insn.exp.X_add_symbol &&
			  prev_insn.exp.X_op == the_insn.exp.X_op &&
			  prev_insn.exp.X_op_symbol == the_insn.exp.X_op_symbol &&
			  prev_insn.exp.X_add_number == the_insn.exp.X_add_number &&
			  prev_fix != NULL)
			prev_fix->fx_r_type = the_insn.reloc;

		      the_insn.format = 17;
		      the_insn.arg_reloc = last_call_desc.arg_reloc;
		      bzero (&last_call_desc, sizeof (call_descS));
		    }
		}
	      else
		{
		  unsigned int w2, w1, w, result;

		  sign_unext (the_insn.exp.X_add_number >> 2, 17, &result);
		  dis_assemble_17 (result, &w1, &w2, &w);
		  opcode |= ((w2 << 2) | (w1 << 16) | w);
		}
#endif
	      s = expr_end;
	      continue;
	    case 'p':		/* 5 bit shift count at 26 (to support SHD instr.) */
	      /* value is encoded in instr. as 31-p where p is   */
	      /* the value scanned here */
	      getExpression (s);
	      if (the_insn.exp.X_op == O_constant)
		{
		  opcode |= (((31 - the_insn.exp.X_add_number) & 0x1f) << 5);
		}
	      s = expr_end;
	      continue;
	    case 'P':		/* 5-bit bit position at 26 */
	      getExpression (s);
	      if (the_insn.exp.X_op == O_constant)
		{
		  opcode |= (the_insn.exp.X_add_number & 0x1f) << 5;
		}
	      s = expr_end;
	      continue;
	    case 'Q':		/* 5  bit immediate at 10 */
	      /* (unsigned bit position value for the bb instruction) */
	      getExpression (s);
	      im5 = evaluateAbsolute (the_insn.exp, the_insn.field_selector);
	      if (im5 > 31)
		{
		  as_bad ("Operand out of range. Was: %d. Should be [0..31]. Assuming %d.\n", im5, im5 & 0x1f);
		  im5 = im5 & 0x1f;
		}
	      opcode |= im5 << 21;
	      s = expr_end;
	      continue;
	    case 'A':		/* 13 bit immediate at 18 (to support BREAK instr.) */
	      getAbsoluteExpression (s);
	      if (the_insn.exp.X_op == O_constant)
		opcode |= (the_insn.exp.X_add_number & 0x1fff) << 13;
	      s = expr_end;
	      continue;
	    case 'Z':		/* System Control Completer(for LDA, LHA, etc.) */
	      if (*s == ',' && (*(s + 1) == 'm' || *(s + 1) == 'M'))
		{
		  m = 1;
		  s += 2;
		}
	      else
		m = 0;

	      opcode |= m << 5;
	      while (*s == ' ' || *s == '\t')	/* skip to next operand */
		s++;

	      continue;
	    case 'D':		/* 26 bit immediate at 31 (to support DIAG instr.) */
	      /* the action (and interpretation of this operand is
			     implementation dependent) */
#if defined(OBJ_ELF)
	      the_insn.field_selector = pa_chk_field_selector (&s);
#endif
	      getExpression (s);
	      if (the_insn.exp.X_op == O_constant)
		{
		  opcode |= ((evaluateAbsolute (the_insn.exp, the_insn.field_selector) & 0x1ffffff) << 1);
#ifdef NEW_SOM			/* XXX what replaces this? */
		  /* PJH: VERY unsure about the following */
		  the_insn.field_selector = the_insn.exp.field_selector;
#endif
		}
	      else
		as_bad ("Illegal DIAG operand");
	      s = expr_end;
	      continue;
	    case 'f':		/* 3 bit Special Function Unit (SFU) identifier at 25 */
	      sfu = pa_parse_number (&s);
	      if ((sfu > 7) || (sfu < 0))
		as_bad ("Illegal SFU identifier: %02x", sfu);
	      opcode |= (sfu & 7) << 6;
	      continue;
	    case 'O':		/* 20 bit SFU op. split between 15 bits at 20
	                   and 5 bits at 31 */
	      getExpression (s);
	      s = expr_end;
	      continue;
	    case 'o':		/* 15 bit Special Function Unit operation at 20 */
	      getExpression (s);
	      s = expr_end;
	      continue;
	    case '2':		/* 22 bit SFU op. split between 17 bits at 20
	                   and 5 bits at 31 */
	      getExpression (s);
	      s = expr_end;
	      continue;
	    case '1':		/* 15 bit SFU op. split between 10 bits at 20
	                   and 5 bits at 31 */
	      getExpression (s);
	      s = expr_end;
	      continue;
	    case '0':		/* 10 bit SFU op. split between 5 bits at 20
	                   and 5 bits at 31 */
	      getExpression (s);
	      s = expr_end;
	      continue;
	    case 'u':		/* 3 bit coprocessor unit identifier at 25 */
	      getExpression (s);
	      s = expr_end;
	      continue;
	    case 'F':		/* Source FP Operand Format Completer (2 bits at 20) */
	      f = pa_parse_fp_format (&s);
	      opcode |= (int) f << 11;
	      the_insn.fpof1 = f;
	      continue;
	    case 'G':		/* Destination FP Operand Format Completer (2 bits at 18) */
	      s--;		/* need to pass the previous comma to pa_parse_fp_format */
	      f = pa_parse_fp_format (&s);
	      opcode |= (int) f << 13;
	      the_insn.fpof2 = f;
	      continue;
	    case 'M':		/* FP Compare Conditions (encoded as 5 bits at 31) */
	      cond = pa_parse_fp_cmp_cond (&s);
	      opcode |= cond;
	      continue;

	    case 'v':		/* a 't' type extended to handle L/R register halves. */
	      {
		struct pa_89_fp_reg_struct result;

		pa_89_parse_number (&s, &result);
		if (result.number_part < 32 && result.number_part >= 0)
		  {
		    opcode |= (result.number_part & 0x1f);

		    /* 0x30 opcodes are FP arithmetic operation opcodes */
		    /* load/store FP opcodes do not get converted to 0x38 */
		    /* opcodes like the 0x30 opcodes do */
		    if (need_89_opcode (&the_insn, &result))
		      {
			if ((opcode & 0xfc000000) == 0x30000000)
			  {
			    opcode |= (result.L_R_select & 1) << 6;
			    opcode |= 1 << 27;
			  }
			else
			  {
			    opcode |= (result.L_R_select & 1) << 6;
			  }
		      }
		    continue;
		  }
	      }
	      break;
	    case 'E':		/* a 'b' type extended to handle L/R register halves. */
	      {
		struct pa_89_fp_reg_struct result;

		pa_89_parse_number (&s, &result);
		if (result.number_part < 32 && result.number_part >= 0)
		  {
		    opcode |= (result.number_part & 0x1f) << 21;
		    if (need_89_opcode (&the_insn, &result))
		      {
			opcode |= (result.L_R_select & 1) << 7;
			opcode |= 1 << 27;
		      }
		    continue;
		  }
	      }
	      break;

	    case 'X':		/* an 'x' type extended to handle L/R register halves. */
	      {
		struct pa_89_fp_reg_struct result;

		pa_89_parse_number (&s, &result);
		if (result.number_part < 32 && result.number_part >= 0)
		  {
		    opcode |= (result.number_part & 0x1f) << 16;
		    if (need_89_opcode (&the_insn, &result))
		      {
			opcode |= (result.L_R_select & 1) << 12;
			opcode |= 1 << 27;
		      }
		    continue;
		  }
	      }
	      break;

	    case '4':		/* 5 bit register field at 10
				 (used in 'fmpyadd' and 'fmpysub') */
	      {
		struct pa_89_fp_reg_struct result;
		int status;

		status = pa_89_parse_number (&s, &result);
		if (result.number_part < 32 && result.number_part >= 0)
		  {
		    if (the_insn.fpof1 == SGL)
		      {
			result.number_part &= 0xF;
			result.number_part |= (result.L_R_select & 1) << 4;
		      }
		    opcode |= result.number_part << 21;
		    continue;
		  }
	      }
	      break;

	    case '6':		/* 5 bit register field at 15
				 (used in 'fmpyadd' and 'fmpysub') */
	      {
		struct pa_89_fp_reg_struct result;
		int status;

		status = pa_89_parse_number (&s, &result);
		if (result.number_part < 32 && result.number_part >= 0)
		  {
		    if (the_insn.fpof1 == SGL)
		      {
			result.number_part &= 0xF;
			result.number_part |= (result.L_R_select & 1) << 4;
		      }
		    opcode |= result.number_part << 16;
		    continue;
		  }
	      }
	      break;

	    case '7':		/* 5 bit register field at 31
				 (used in 'fmpyadd' and 'fmpysub') */
	      {
		struct pa_89_fp_reg_struct result;
		int status;

		status = pa_89_parse_number (&s, &result);
		if (result.number_part < 32 && result.number_part >= 0)
		  {
		    if (the_insn.fpof1 == SGL)
		      {
			result.number_part &= 0xF;
			result.number_part |= (result.L_R_select & 1) << 4;
		      }
		    opcode |= result.number_part;
		    continue;
		  }
	      }
	      break;

	    case '8':		/* 5 bit register field at 20
				 (used in 'fmpyadd' and 'fmpysub') */
	      {
		struct pa_89_fp_reg_struct result;
		int status;

		status = pa_89_parse_number (&s, &result);
		if (result.number_part < 32 && result.number_part >= 0)
		  {
		    if (the_insn.fpof1 == SGL)
		      {
			result.number_part &= 0xF;
			result.number_part |= (result.L_R_select & 1) << 4;
		      }
		    opcode |= result.number_part << 11;
		    continue;
		  }
	      }
	      break;

	    case '9':		/* 5 bit register field at 25
				 (used in 'fmpyadd' and 'fmpysub') */
	      {
		struct pa_89_fp_reg_struct result;
		int status;

		status = pa_89_parse_number (&s, &result);
		if (result.number_part < 32 && result.number_part >= 0)
		  {
		    if (the_insn.fpof1 == SGL)
		      {
			result.number_part &= 0xF;
			result.number_part |= (result.L_R_select & 1) << 4;
		      }
		    opcode |= result.number_part << 6;
		    continue;
		  }
	      }
	      break;

	    case 'H':		/* Floating Point Operand Format at 26 for       */
	      /* 'fmpyadd' and 'fmpysub' (very similar to 'F') */
	      /* bits are switched from other FP Operand       */
	      /* formats. 1=SGL, 1=<none>, 0=DBL               */
	      f = pa_parse_fp_format (&s);
	      switch (f)
		{
		case SGL:
		  opcode |= 0x20;
		case DBL:
		  the_insn.fpof1 = f;
		  continue;

		case QUAD:
		case ILLEGAL_FMT:
		default:
		  as_bad ("Illegal Floating Point Operand Format for this instruction: '%s'", *s);
		}
	      break;

	    default:
	      abort ();
	    }
	  break;
	}

      if (match == FALSE)
	{
	  /* Args don't match.  */
	  if (&insn[1] - pa_opcodes < NUMOPCODES
	      && !strcmp (insn->name, insn[1].name))
	    {
	      ++insn;
	      s = argsStart;
	      continue;
	    }
	  else
	    {
	      as_bad ("Illegal operands %s", error_message);
	      return;
	    }
	}
      break;
    }

  the_insn.opcode = opcode;

#ifdef PA_DEBUG
  if (the_insn.exp.X_add_symbol && the_insn.exp.X_op_symbol)
    print_insn_short (&the_insn);
  fprintf (stderr, "*********** END OF STATEMENT\n");
#endif

  return;
}

/*
    This is identical to the md_atof in m68k.c.  I think this is right,
    but I'm not sure.

   Turn a string in input_line_pointer into a floating point constant of type
   type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
   emitted is stored in *sizeP .  An error message is returned, or NULL on OK.
 */

/* Equal to MAX_PRECISION in atof-ieee.c */
#define MAX_LITTLENUMS 6

char *
md_atof (type, litP, sizeP)
     char type;
     char *litP;
     int *sizeP;
{
  int prec;
  LITTLENUM_TYPE words[MAX_LITTLENUMS];
  LITTLENUM_TYPE *wordP;
  char *t;
  char *atof_ieee ();

  switch (type)
    {

    case 'f':
    case 'F':
    case 's':
    case 'S':
      prec = 2;
      break;

    case 'd':
    case 'D':
    case 'r':
    case 'R':
      prec = 4;
      break;

    case 'x':
    case 'X':
      prec = 6;
      break;

    case 'p':
    case 'P':
      prec = 6;
      break;

    default:
      *sizeP = 0;
      return "Bad call to MD_ATOF()";
    }
  t = atof_ieee (input_line_pointer, type, words);
  if (t)
    input_line_pointer = t;
  *sizeP = prec * sizeof (LITTLENUM_TYPE);
  for (wordP = words; prec--;)
    {
      md_number_to_chars (litP, (long) (*wordP++), sizeof (LITTLENUM_TYPE));
      litP += sizeof (LITTLENUM_TYPE);
    }
  return "";			/* Someone should teach Dean about null pointers */
}

/*
 * Write out big-endian.
 */
void
md_number_to_chars (buf, val, n)
     char *buf;
     valueT val;
     int n;
{

  switch (n)
    {

    case 4:
      *buf++ = val >> 24;
      *buf++ = val >> 16;
    case 2:
      *buf++ = val >> 8;
    case 1:
      *buf = val;
      break;

    default:
      abort ();
    }
  return;
}

void
md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
     char *ptr;
     addressT from_addr, to_addr;
     fragS *frag;
     symbolS *to_symbol;
{
  fprintf (stderr, "pa_create_short_jmp\n");
  abort ();
}

void
md_number_to_disp (buf, val, n)
     char *buf;
     long val;
     int n;
{
  fprintf (stderr, "md_number_to_disp\n");
  abort ();
}

void
md_number_to_field (buf, val, fix)
     char *buf;
     long val;
     void *fix;
{
  fprintf (stderr, "pa_number_to_field\n");
  abort ();
}

/* the bit-field entries in the relocation_info struct plays hell
   with the byte-order problems of cross-assembly.  So as a hack,
   I added this mach. dependent ri twiddler.  Ugly, but it gets
   you there. -KWK */
/* on sparc: first 4 bytes are normal unsigned long address, next three
   bytes are index, most sig. byte first.  Byte 7 is broken up with
   bit 7 as external, bits 6 & 5 unused, and the lower
   five bits as relocation type.  Next 4 bytes are long int addend. */
/* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com */

#ifdef OBJ_SOM
void
md_ri_to_chars (ri_p, ri)
     struct reloc_info_pa *ri_p, ri;
{
  unsigned char the_bytes[sizeof (*ri_p)];
#if defined(OBJ_SOM) | defined(OBJ_OSFROSE) | defined(OBJ_ELF)
  /* not sure what, if any, changes are required for new-style cross-assembly */
#else
  the_bytes[0] = ((ri.need_data_ref << 7) & 0x80) | ((ri.arg_reloc & 0x03f8) >> 3);
  the_bytes[1] = ((ri.arg_reloc & 0x07) << 5) | ri.expression_type;
  the_bytes[2] = ((ri.exec_level << 6) & 0xc0) | ri.fixup_format;
  the_bytes[3] = ri.fixup_field & 0xff;
  md_number_to_chars (&the_bytes[4], ri.subspace_offset, sizeof (ri.subspace_offset));
  md_number_to_chars (&the_bytes[8], ri.symbol_index_one, sizeof (ri.symbol_index_one));
  md_number_to_chars (&the_bytes[12], ri.symbol_index_two, sizeof (ri.symbol_index_two));
  md_number_to_chars (&the_bytes[16], ri.fixup_constant, sizeof (ri.fixup_constant));

  /* now put it back where you found it, Junior... */
  bcopy (the_bytes, (char *) ri_p, sizeof (*ri_p));
#endif

}

#endif


/* Translate internal representation of relocation info to BFD target
   format.  */
/* This may need additional work to make sure that SOM support is complete. */
#ifdef OBJ_ELF
arelent **
tc_gen_reloc (section, fixp)
     asection *section;
     fixS *fixp;
{
  arelent *reloc;
  hppa_fixS *hppa_fixp = hppa_find_hppa_fix (fixp);
  bfd_reloc_code_real_type code;
  static int unwind_reloc_fixp_cnt = 0;
  static arelent *unwind_reloc_entryP = NULL;
  static arelent *no_relocs = NULL;
  arelent **relocs;
  bfd_reloc_code_real_type **codes;
  int n_relocs;
  int i;

  if (fixp->fx_addsy == 0)
    return &no_relocs;
  assert (hppa_fixp != 0);
  assert (section != 0);

  /* unwind section relocations are handled in a special way. */
  /* The relocations for the .unwind section are originally */
  /* built in the usual way.  That is, for each unwind table */
  /* entry there are two relocations:  one for the beginning of */
  /* the function and one for the end.	*/

  /* The first time we enter this function we create a */
  /* relocation of the type R_HPPA_UNWIND_ENTRIES.  The addend */
  /* of the relocation is initialized to 0.  Each additional */
  /* pair of times this function is called for the unwind */
  /* section represents an additional unwind table entry.  Thus, */
  /* the addend of the relocation should end up to be the number */
  /* of unwind table entries. */
  if (strcmp (UNWIND_SECTION_NAME, section->name) == 0)
    {
      if (unwind_reloc_entryP == NULL)
	{
	  reloc = (arelent *) bfd_alloc_by_size_t (stdoutput, sizeof (arelent));
	  assert (reloc != 0);
	  unwind_reloc_entryP = reloc;
	  unwind_reloc_fixp_cnt++;
	  unwind_reloc_entryP->address = fixp->fx_frag->fr_address + fixp->fx_where;
	  /* a pointer any function will do.  We only */
	  /* need one to tell us what section the unwind */
	  /* relocations are for. */
	  unwind_reloc_entryP->sym_ptr_ptr = &fixp->fx_addsy->bsym;
	  code = R_HPPA_UNWIND_ENTRIES;
	  unwind_reloc_entryP->howto = bfd_reloc_type_lookup (stdoutput, code);
	  unwind_reloc_entryP->addend = unwind_reloc_fixp_cnt / 2;
	  relocs = (arelent **) bfd_alloc_by_size_t (stdoutput, sizeof (arelent *) * 2);
	  assert (relocs != 0);
	  relocs[0] = unwind_reloc_entryP;
	  relocs[1] = NULL;
	  return relocs;
	}
      unwind_reloc_fixp_cnt++;
      unwind_reloc_entryP->addend = unwind_reloc_fixp_cnt / 2;

      return &no_relocs;
    }

  reloc = (arelent *) bfd_alloc_by_size_t (stdoutput, sizeof (arelent));
  assert (reloc != 0);

  reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
  /* XXX: might need additional processing here	*/
  /* hppa_elf_gen_reloc_type() is defined in the	*/
  /* ELF/PA BFD back-end				*/
  codes = hppa_elf_gen_reloc_type (stdoutput,
				   fixp->fx_r_type,
				   hppa_fixp->fx_r_format,
				   hppa_fixp->fx_r_field);

  for (n_relocs = 0; codes[n_relocs]; n_relocs++)
    ;

  relocs = (arelent **) bfd_alloc_by_size_t (stdoutput, sizeof (arelent *) * n_relocs + 1);
  assert (relocs != 0);

  reloc = (arelent *) bfd_alloc_by_size_t (stdoutput, sizeof (arelent) * n_relocs);
  if (n_relocs > 0)
    assert (reloc != 0);

  for (i = 0; i < n_relocs; i++)
    relocs[i] = &reloc[i];

  relocs[n_relocs] = NULL;

  switch (fixp->fx_r_type)
    {
    case R_HPPA_COMPLEX:
    case R_HPPA_COMPLEX_PCREL_CALL:
    case R_HPPA_COMPLEX_ABS_CALL:
      assert (n_relocs == 5);

      for (i = 0; i < n_relocs; i++)
	{
	  reloc[i].sym_ptr_ptr = NULL;
	  reloc[i].address = 0;
	  reloc[i].addend = 0;
	  reloc[i].howto = bfd_reloc_type_lookup (stdoutput, *codes[i]);
	  assert (reloc[i].howto && *codes[i] == reloc[i].howto->type);
	}

      reloc[0].sym_ptr_ptr = &fixp->fx_addsy->bsym;
      reloc[1].sym_ptr_ptr = &fixp->fx_subsy->bsym;
      reloc[4].address = fixp->fx_frag->fr_address + fixp->fx_where;

      if (fixp->fx_r_type == R_HPPA_COMPLEX)
	reloc[3].addend = fixp->fx_addnumber;
      else if (fixp->fx_r_type == R_HPPA_COMPLEX_PCREL_CALL ||
	       fixp->fx_r_type == R_HPPA_COMPLEX_ABS_CALL)
	reloc[1].addend = fixp->fx_addnumber;

      break;

    default:
      assert (n_relocs == 1);

      code = *codes[0];

      reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
      reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
      reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
      reloc->addend = 0;	/* default */

      assert (reloc->howto && code == reloc->howto->type);

      /* Now, do any processing that is dependent on the relocation */
      /* type. */
      switch (code)
	{
	case R_HPPA_PLABEL_32:
	case R_HPPA_PLABEL_11:
	case R_HPPA_PLABEL_14:
	case R_HPPA_PLABEL_L21:
	case R_HPPA_PLABEL_R11:
	case R_HPPA_PLABEL_R14:
	  /* For plabel relocations, the addend of the */
	  /* relocation should be either 0 (no static link) or 2 */
	  /* (static link required).	*/
	  /* XXX: assume that fx_addnumber contains this */
	  /* information */
	  reloc->addend = fixp->fx_addnumber;
	  break;

	case R_HPPA_ABS_CALL_11:
	case R_HPPA_ABS_CALL_14:
	case R_HPPA_ABS_CALL_17:
	case R_HPPA_ABS_CALL_L21:
	case R_HPPA_ABS_CALL_R11:
	case R_HPPA_ABS_CALL_R14:
	case R_HPPA_ABS_CALL_R17:
	case R_HPPA_ABS_CALL_LS21:
	case R_HPPA_ABS_CALL_RS11:
	case R_HPPA_ABS_CALL_RS14:
	case R_HPPA_ABS_CALL_RS17:
	case R_HPPA_ABS_CALL_LD21:
	case R_HPPA_ABS_CALL_RD11:
	case R_HPPA_ABS_CALL_RD14:
	case R_HPPA_ABS_CALL_RD17:
	case R_HPPA_ABS_CALL_LR21:
	case R_HPPA_ABS_CALL_RR14:
	case R_HPPA_ABS_CALL_RR17:

	case R_HPPA_PCREL_CALL_11:
	case R_HPPA_PCREL_CALL_14:
	case R_HPPA_PCREL_CALL_17:
	case R_HPPA_PCREL_CALL_L21:
	case R_HPPA_PCREL_CALL_R11:
	case R_HPPA_PCREL_CALL_R14:
	case R_HPPA_PCREL_CALL_R17:
	case R_HPPA_PCREL_CALL_LS21:
	case R_HPPA_PCREL_CALL_RS11:
	case R_HPPA_PCREL_CALL_RS14:
	case R_HPPA_PCREL_CALL_RS17:
	case R_HPPA_PCREL_CALL_LD21:
	case R_HPPA_PCREL_CALL_RD11:
	case R_HPPA_PCREL_CALL_RD14:
	case R_HPPA_PCREL_CALL_RD17:
	case R_HPPA_PCREL_CALL_LR21:
	case R_HPPA_PCREL_CALL_RR14:
	case R_HPPA_PCREL_CALL_RR17:
	  /* constant is stored in the instruction */
	  reloc->addend = ELF32_HPPA_R_ADDEND (hppa_fixp->fx_arg_reloc, 0);
	  break;
	default:
	  reloc->addend = fixp->fx_addnumber;
	  break;
	}
      break;
    }

  return relocs;
}

#else
arelent *
tc_gen_reloc (section, fixp)
     asection *section;
     fixS *fixp;
{
  arelent *reloc;
  hppa_fixS *hppa_fixp = hppa_find_hppa_fix (fixp);
  bfd_reloc_code_real_type code;

  if (fixp->fx_addsy == 0)
    return 0;
  assert (hppa_fixp != 0);
  assert (section != 0);

  reloc = (arelent *) bfd_alloc_by_size_t (stdoutput, sizeof (arelent));
  assert (reloc != 0);

  reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
  /* XXX: might need additional processing here   */
  /* hppa_elf_gen_reloc_type() is defined in the  */
  /* ELF/PA BFD back-end                          */
  code = hppa_elf_gen_reloc_type (stdoutput,
				  fixp->fx_r_type,
				  hppa_fixp->fx_r_format,
				  hppa_fixp->fx_r_field);
  reloc->howto = bfd_reloc_type_lookup (stdoutput, code);

  assert (code == reloc->howto->type);

  reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
  reloc->addend = 0;		/* default */

  /* Now, do any processing that is dependent on the relocation */
  /* type. (Is there any?) */
  switch (code)
    {
    default:
      reloc->addend = fixp->fx_addnumber;
      break;
    }

  return reloc;
}

#endif

void
md_convert_frag (abfd, sec, fragP)
     register bfd *abfd;
     register asection *sec;
     register fragS *fragP;
{
  unsigned int address;

  if (fragP->fr_type == rs_machine_dependent)
    {
      switch ((int) fragP->fr_subtype)
	{
	case 0:
	  fragP->fr_type = rs_fill;
	  know (fragP->fr_var == 1);
	  know (fragP->fr_next);
	  address = fragP->fr_address + fragP->fr_fix;
	  if (address % fragP->fr_offset)
	    {
	      fragP->fr_offset =
		fragP->fr_next->fr_address
		- fragP->fr_address
		- fragP->fr_fix;
	    }
	  else
	    fragP->fr_offset = 0;
	  break;
	}
    }
}

/* Round up a section size to the appropriate boundary. */
valueT
md_section_align (segment, size)
     asection *segment;
     valueT size;
{
  return (size + 7) & ~7;	/* Round all sects to multiple of 8 */
}				/* md_section_align() */

void
md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
     char *ptr;
     addressT from_addr, to_addr;
     fragS *frag;
     symbolS *to_symbol;
{
  fprintf (stderr, "pa_create_long_jump\n");
  abort ();
}

int
/* md_estimate_size_before_relax(fragP, segtype) */
md_estimate_size_before_relax (fragP, segment)
     register fragS *fragP;
     asection *segment;
{
  int size;

  size = 0;

  while ((fragP->fr_fix + size) % fragP->fr_offset)
    size++;

  return size;
}

int
md_parse_option (argP, cntP, vecP)
     char **argP;
     int *cntP;
     char ***vecP;
{
  return 1;
}

/* We have no need to default values of symbols. */

/* ARGSUSED */
symbolS *
md_undefined_symbol (name)
     char *name;
{
  return 0;
}				/*md_undefined_symbol() */

/* Parse an operand that is machine-specific.
   We just return without modifying the expression if we have nothing
   to do.  */

/* ARGSUSED */
void
md_operand (expressionP)
     expressionS *expressionP;
{
}

/* Apply a fixS to the frags, now that we know the value it ought to
   hold. */

int 
apply_field_selector (value, constant, field_selector)
     long value;
     long constant;
     int field_selector;
{
  /* hppa_field_adjust() is defined in the HPPA target */
  return hppa_field_adjust (value, constant, field_selector);
}

void 
md_apply_fix_1 (fixP, val)
     fixS *fixP;
     long val;
{
  char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
  hppa_fixS *hppa_fixP = hppa_find_hppa_fix (fixP);
  long new_val;
  long result;
  unsigned int w1, w2, w;
  /* The following routine is defined in the ELF/PA back-end	*/
  extern unsigned char hppa_elf_insn2fmt ();

  if (hppa_fixP)
    {
      unsigned long buf_wd = bfd_get_32 (stdoutput, buf);
      unsigned char fmt = hppa_elf_insn2fmt (fixP->fx_r_type, buf_wd);

      assert (fixP->fx_r_type < R_HPPA_UNIMPLEMENTED);
      assert (fixP->fx_r_type >= R_HPPA_NONE);

      fixP->fx_addnumber = val;	/* Remember value for emit_reloc */

      /* Check if this is an undefined symbol.  No relocation can	*/
      /* possibly be performed in this case.				*/

      if ((fixP->fx_addsy && fixP->fx_addsy->bsym->section == &bfd_und_section)
	  || (fixP->fx_subsy && fixP->fx_subsy->bsym->section == &bfd_und_section))
	return;

      switch (fmt)
	{

	case 14:		/* all the opcodes with the 'j' operand type */
	  new_val = apply_field_selector (val, 0, hppa_fixP->fx_r_field);
	  /* need to check for overflow here */

	  /* mask off 14 bits to be changed */
	  bfd_put_32 (stdoutput,
		      bfd_get_32 (stdoutput, buf) & 0xffffc000,
		      buf);
	  low_sign_unext (new_val, 14, &result);
	  break;

	case 21:		/* all the opcodes with the 'k' operand type */
	  new_val = apply_field_selector (val, 0, hppa_fixP->fx_r_field);
	  /* need to check for overflow here */

	  /* mask off 21 bits to be changed */
	  bfd_put_32 (stdoutput,
		      bfd_get_32 (stdoutput, buf) & 0xffe00000,
		      buf);
	  dis_assemble_21 (new_val, &result);
	  break;

	case 11:		/* all the opcodes with the 'i' operand type */
	  new_val = apply_field_selector (val, 0, hppa_fixP->fx_r_field);
	  /* need to check for overflow here */

	  /* mask off 11 bits to be changed */
	  bfd_put_32 (stdoutput,
		      bfd_get_32 (stdoutput, buf) & 0xffff800,
		      buf);
	  low_sign_unext (new_val, 11, &result);
	  break;

	case 12:		/* all the opcodes with the 'w' operand type */
	  new_val = apply_field_selector (val, 0, hppa_fixP->fx_r_field);

	  /* mask off 11 bits to be changed */
	  sign_unext ((new_val - 8) >> 2, 12, &result);
	  bfd_put_32 (stdoutput,
		      bfd_get_32 (stdoutput, buf) & 0xffffe002,
		      buf);

	  dis_assemble_12 (result, &w1, &w);
	  result = ((w1 << 2) | w);
	  fixP->fx_addsy = NULL; /* No relocations please.  */
	  break;

#define too_far(VAL, NUM_BITS) \
  (((int)(VAL) > (1 << (NUM_BITS)) - 1) || ((int)(VAL) < (-1 << (NUM_BITS))))

#define stub_needed(CALLER, CALLEE) \
  ((CALLEE) && (CALLER) && ((CALLEE) != (CALLER)))

	case 17:		/* some of the opcodes with the 'W' operand type */
	  if (too_far (val, 18)
	      || stub_needed (((elf32_symbol_type *) fixP->fx_addsy->bsym)->tc_data.hppa_arg_reloc,
			      hppa_fixP->fx_arg_reloc))
	    /* Keep the relocation because we can't reach the target with
	       a short call, or if an argument relocation stub is needed.  */
	    return;

	  new_val = apply_field_selector (val, 0, hppa_fixP->fx_r_field);
	  /* need to check for overflow here */

	  /* mask off 17 bits to be changed */
	  bfd_put_32 (stdoutput,
		      bfd_get_32 (stdoutput, buf) & 0xffe0e002,
		      buf);
	  sign_unext ((new_val - 8) >> 2, 17, &result);
	  dis_assemble_17 (result, &w1, &w2, &w);
	  result = ((w2 << 2) | (w1 << 16) | w);
	  fixP->fx_addsy = NULL; /* No relocations please. */
	  break;

	case 32:
	  if (hppa_fixP->fx_r_type == R_HPPA_UNWIND_ENTRY
	      || hppa_fixP->fx_r_type == R_HPPA_UNWIND_ENTRIES)
	    result = fixP->fx_addnumber;
	  else
	    {
	      result = 0;
	      fixP->fx_addnumber = fixP->fx_offset;
	      bfd_put_32 (stdoutput, 0, buf); /* clear out everything */
	      return;		/* still need the relocation */
	    }
	  break;

	case 0:
	  return;

	default:
	  as_bad ("bad relocation type/fmt: 0x%02x/0x%02x",
		  fixP->fx_r_type, fmt);
	  return;
	}
      buf[0] |= (result & 0xff000000) >> 24;
      buf[1] |= (result & 0x00ff0000) >> 16;
      buf[2] |= (result & 0x0000ff00) >> 8;
      buf[3] |= result & 0x000000ff;
      /* We've now adjusted for fx_addnumber, we can */
      /* forget it now. */
      fixP->fx_addnumber = 0;
    }
  else
    {
      printf ("no hppa_fixup entry for this fixup (fixP = 0x%x, type = 0x%x)\n",
	      fixP, fixP->fx_r_type);
    }
}				/* md_apply_fix_1() */

#ifdef BFD_ASSEMBLER
int
md_apply_fix (fixP, valp)
     fixS *fixP;
     valueT *valp;
{
  md_apply_fix_1 (fixP, *valp);
  return 1;
}

#else
void
md_apply_fix (fixP, val)
     fixS *fixP;
     long val;
{
  md_apply_fix_1 (fixP, val);
}

#endif

/* Exactly what point is a PC-relative offset relative TO?
   On the PA, they're relative to the address of the offset.
   (??? Is this right?  FIXME-SOON) */
long 
md_pcrel_from (fixP)
     fixS *fixP;
{
  return fixP->fx_where + fixP->fx_frag->fr_address;
}				/* md_pcrel_from() */

int 
is_end_of_statement ()
{
  return ((*input_line_pointer == '\n')
	  || (*input_line_pointer == ';')
	  || (*input_line_pointer == '!'));
}

/* pa-aux.c -- Assembler for the PA - PA-RISC specific support routines */

struct aux_hdr_list *aux_hdr_root = NULL;

int print_errors = 1;

void 
pa_skip (s)
     char **s;
{
  while (**s == ' ' || **s == '\t')
    *s = *s + 1;
}

int 
pa_parse_number (s)
     char **s;
{
  int num;
  char *name;
  char c;
  symbolS *sym;
  int status;
  char *p = *s;

  while (*p == ' ' || *p == '\t')
    p = p + 1;
  num = -1;			/* assume invalid number to begin with */
  if (isdigit (*p))
    {
      num = 0;			/* now we know it is a number */

      if (*p == '0' && (*(p + 1) == 'x' || *(p + 1) == 'X'))
	{			/* hex input */
	  p = p + 2;
	  while (isdigit (*p) || ((*p >= 'a') && (*p <= 'f'))
		 || ((*p >= 'A') && (*p <= 'F')))
	    {
	      if (isdigit (*p))
		num = num * 16 + *p - '0';
	      else if (*p >= 'a' && *p <= 'f')
		num = num * 16 + *p - 'a' + 10;
	      else
		num = num * 16 + *p - 'A' + 10;
	      ++p;
	    }
	}
      else
	{
	  while (isdigit (*p))
	    {
	      num = num * 10 + *p - '0';
	      ++p;
	    }
	}
    }
  else if (*p == '%')
    {				/* could be a pre-defined register */
      num = 0;
      name = p;
      p++;
      c = *p;
      /* tege hack: Special case for general registers
       as the general code makes a binary search with case translation,
       and is VERY slow.  */
      if (c == 'r')
	{
	  p++;
	  if (*p == 'e' && *(p + 1) == 't' && (*(p + 2) == '0' || *(p + 2) == '1'))
	    {
	      p += 2;
	      num = *p - '0' + 28;	/* r28 is ret0 */
	      p++;
	    }
	  else if (!isdigit (*p))
	    as_bad ("Undefined register: '%s'. ASSUMING 0", name);
	  else
	    {
	      do
		num = num * 10 + *p++ - '0';
	      while (isdigit (*p));
	    }
	}
      else
	{
	  while (is_part_of_name (c))
	    {
	      p = p + 1;
	      c = *p;
	    }
	  *p = 0;
	  status = reg_name_search (name);
	  if (status >= 0)
	    num = status;
	  else
	    {
	      if (print_errors)
		as_bad ("Undefined register: '%s'. ASSUMING 0", name);
	      else
		num = -1;
	    }
	  *p = c;
	}
    }
  else
    {
      num = 0;
      name = p;
      c = *p;
      while (is_part_of_name (c))
	{
	  p = p + 1;
	  c = *p;
	}
      *p = 0;
      if ((sym = symbol_find (name)) != NULL)
	{
#ifdef OBJ_SOM
	  if (sym->pa_sy_type == ST_ABSOLUTE)
	    {
	      num = sym->pa_sy_value;
#else
	  if (S_GET_SEGMENT (sym) == &bfd_abs_section)
	    {
	      num = S_GET_VALUE (sym);
#endif
	    }
	  else
	    {
	      if (print_errors)
		as_bad ("Non-absolute constant: '%s'. ASSUMING 0", name);
	      else
		num = -1;
	    }
	}
      else
	{
	  if (print_errors)
	    as_bad ("Undefined absolute constant: '%s'. ASSUMING 0", name);
	  else
	    num = -1;
	}
      *p = c;
    }

  *s = p;
  return num;
}

struct pd_reg
  {
    char *name;
    int value;
  };

/*	List of registers that are pre-defined:

	General Registers:

	Name	Value		Name	Value
	%r0	0		%r16	16
	%r1	1		%r17	17
	%r2	2		%r18	18
	%r3	3		%r19	19
	%r4	4		%r20	20
	%r5	5		%r21	21
	%r6	6		%r22	22
	%r7	7		%r23	23
	%r8	8		%r24	24
	%r9	9		%r25	25
	%r10	10		%r26	26
	%r11	11		%r27	27
	%r12	12		%r28	28
	%r13	13		%r29	29
	%r14	14		%r30	30
	%r15	15		%r31	31

	Floating-point Registers:
	[NOTE:  Also includes L and R versions of these (e.g. %fr19L, %fr19R)]

	Name	Value		Name	Value
	%fr0	0		%fr16	16
	%fr1	1		%fr17	17
	%fr2	2		%fr18	18
	%fr3	3		%fr19	19
	%fr4	4		%fr20	20
	%fr5	5		%fr21	21
	%fr6	6		%fr22	22
	%fr7	7		%fr23	23
        %fr8	8		%fr24	24
	%fr9	9		%fr25	25
	%fr10	10		%fr26	26
	%fr11	11		%fr27	27
	%fr12	12		%fr28	28
	%fr13	13		%fr29	29
	%fr14	14		%fr30	30
	%fr15	15		%fr31	31

	Space Registers:

	Name	Value		Name	Value
	%sr0	0		%sr4	4
	%sr1	1		%sr5	5
	%sr2	2		%sr6	6
	%sr3	3		%sr7	7

	Control registers and their synonyms:

	Names			Value
	%cr0	%rctr		0
	%cr8	%pidr1		8
	%cr9	%pidr2		9
	%cr10	%ccr		10
	%cr11	%sar		11
	%cr12	%pidr3		12
	%cr13	%pidr4		13
	%cr14	%iva		14
	%cr15	%eiem		15
	%cr16	%itmr		16
	%cr17	%pcsq		17
	%cr18	%pcoq		18
	%cr19	%iir		19
	%cr20	%isr		20
	%cr21	%ior		21
	%cr22	%ipsw		22
	%cr23	%eirr		23
	%cr24	%tr0 %ppda	24
	%cr25	%tr1 %hta	25
	%cr26	%tr2		26
	%cr27	%tr3		27
	%cr28	%tr4		28
	%cr29	%tr5		29
	%cr30	%tr6		30
	%cr31	%tr7		31

	Miscellaneous registers and their synonyms:

	Names			Value
	%arg0			26
	%arg1			25
	%arg2			24
	%arg3			23
	%sp			30
	%ret0			28
	%ret1			29
*/

/* This table is sorted. Suitable for searching by a binary search. */

static struct pd_reg pre_defined_registers[] =
{
  {"%arg0", 26},
  {"%arg1", 25},
  {"%arg2", 24},
  {"%arg3", 23},
  {"%cr0", 0},
  {"%cr10", 10},
  {"%cr11", 11},
  {"%cr12", 12},
  {"%cr13", 13},
  {"%cr14", 14},
  {"%cr15", 15},
  {"%cr16", 16},
  {"%cr17", 17},
  {"%cr18", 18},
  {"%cr19", 19},
  {"%cr20", 20},
  {"%cr21", 21},
  {"%cr22", 22},
  {"%cr23", 23},
  {"%cr24", 24},
  {"%cr25", 25},
  {"%cr26", 26},
  {"%cr27", 27},
  {"%cr28", 28},
  {"%cr29", 29},
  {"%cr30", 30},
  {"%cr31", 31},
  {"%cr8", 8},
  {"%cr9", 9},
  {"%eiem", 15},
  {"%eirr", 23},
  {"%fr0", 0},
  {"%fr0L", 0},
  {"%fr0R", 0},
  {"%fr1", 1},
  {"%fr10", 10},
  {"%fr10L", 10},
  {"%fr10R", 10},
  {"%fr11", 11},
  {"%fr11L", 11},
  {"%fr11R", 11},
  {"%fr12", 12},
  {"%fr12L", 12},
  {"%fr12R", 12},
  {"%fr13", 13},
  {"%fr13L", 13},
  {"%fr13R", 13},
  {"%fr14", 14},
  {"%fr14L", 14},
  {"%fr14R", 14},
  {"%fr15", 15},
  {"%fr15L", 15},
  {"%fr15R", 15},
  {"%fr16", 16},
  {"%fr16L", 16},
  {"%fr16R", 16},
  {"%fr17", 17},
  {"%fr17L", 17},
  {"%fr17R", 17},
  {"%fr18", 18},
  {"%fr18L", 18},
  {"%fr18R", 18},
  {"%fr19", 19},
  {"%fr19L", 19},
  {"%fr19R", 19},
  {"%fr1L", 1},
  {"%fr1R", 1},
  {"%fr2", 2},
  {"%fr20", 20},
  {"%fr20L", 20},
  {"%fr20R", 20},
  {"%fr21", 21},
  {"%fr21L", 21},
  {"%fr21R", 21},
  {"%fr22", 22},
  {"%fr22L", 22},
  {"%fr22R", 22},
  {"%fr23", 23},
  {"%fr23L", 23},
  {"%fr23R", 23},
  {"%fr24", 24},
  {"%fr24L", 24},
  {"%fr24R", 24},
  {"%fr25", 25},
  {"%fr25L", 25},
  {"%fr25R", 25},
  {"%fr26", 26},
  {"%fr26L", 26},
  {"%fr26R", 26},
  {"%fr27", 27},
  {"%fr27L", 27},
  {"%fr27R", 27},
  {"%fr28", 28},
  {"%fr28L", 28},
  {"%fr28R", 28},
  {"%fr29", 29},
  {"%fr29L", 29},
  {"%fr29R", 29},
  {"%fr2L", 2},
  {"%fr2R", 2},
  {"%fr3", 3},
  {"%fr30", 30},
  {"%fr30L", 30},
  {"%fr30R", 30},
  {"%fr31", 31},
  {"%fr31L", 31},
  {"%fr31R", 31},
  {"%fr3L", 3},
  {"%fr3R", 3},
  {"%fr4", 4},
  {"%fr4L", 4},
  {"%fr4R", 4},
  {"%fr5", 5},
  {"%fr5L", 5},
  {"%fr5R", 5},
  {"%fr6", 6},
  {"%fr6L", 6},
  {"%fr6R", 6},
  {"%fr7", 7},
  {"%fr7L", 7},
  {"%fr7R", 7},
  {"%fr8", 8},
  {"%fr8L", 8},
  {"%fr8R", 8},
  {"%fr9", 9},
  {"%fr9L", 9},
  {"%fr9R", 9},
  {"%hta", 25},
  {"%iir", 19},
  {"%ior", 21},
  {"%ipsw", 22},
  {"%isr", 20},
  {"%itmr", 16},
  {"%iva", 14},
  {"%pcoq", 18},
  {"%pcsq", 17},
  {"%pidr1", 8},
  {"%pidr2", 9},
  {"%pidr3", 12},
  {"%pidr4", 13},
  {"%ppda", 24},
  {"%r0", 0},
  {"%r1", 1},
  {"%r10", 10},
  {"%r11", 11},
  {"%r12", 12},
  {"%r13", 13},
  {"%r14", 14},
  {"%r15", 15},
  {"%r16", 16},
  {"%r17", 17},
  {"%r18", 18},
  {"%r19", 19},
  {"%r2", 2},
  {"%r20", 20},
  {"%r21", 21},
  {"%r22", 22},
  {"%r23", 23},
  {"%r24", 24},
  {"%r25", 25},
  {"%r26", 26},
  {"%r27", 27},
  {"%r28", 28},
  {"%r29", 29},
  {"%r3", 3},
  {"%r30", 30},
  {"%r31", 31},
  {"%r4", 4},
  {"%r4L", 4},
  {"%r4R", 4},
  {"%r5", 5},
  {"%r5L", 5},
  {"%r5R", 5},
  {"%r6", 6},
  {"%r6L", 6},
  {"%r6R", 6},
  {"%r7", 7},
  {"%r7L", 7},
  {"%r7R", 7},
  {"%r8", 8},
  {"%r8L", 8},
  {"%r8R", 8},
  {"%r9", 9},
  {"%r9L", 9},
  {"%r9R", 9},
  {"%rctr", 0},
  {"%ret0", 28},
  {"%ret1", 29},
  {"%sar", 11},
  {"%sp", 30},
  {"%sr0", 0},
  {"%sr1", 1},
  {"%sr2", 2},
  {"%sr3", 3},
  {"%sr4", 4},
  {"%sr5", 5},
  {"%sr6", 6},
  {"%sr7", 7},
  {"%tr0", 24},
  {"%tr1", 25},
  {"%tr2", 26},
  {"%tr3", 27},
  {"%tr4", 28},
  {"%tr5", 29},
  {"%tr6", 30},
  {"%tr7", 31}
};

#define REG_NAME_CNT	(sizeof(pre_defined_registers) / sizeof(struct pd_reg))

int 
reg_name_search (name)
     char *name;
{
  int x, l, r;

  l = 0;
  r = REG_NAME_CNT - 1;

  do
    {
      x = (l + r) / 2;
      if (strcasecmp (name, pre_defined_registers[x].name) < 0)
	r = x - 1;
      else
	l = x + 1;
    }
  while (!((strcasecmp (name, pre_defined_registers[x].name) == 0) ||
	   (l > r)));

  if (strcasecmp (name, pre_defined_registers[x].name) == 0)
    return (pre_defined_registers[x].value);
  else
    return (-1);

}

int 
is_pre_defined_register (s)
     char *s;
{
  if (reg_name_search (s) >= 0)
    return (TRUE);
  else
    return (FALSE);
}

int 
is_R_select (s)
     char *s;
{

  if (*s == 'R' || *s == 'r')
    return (TRUE);
  else
    return (FALSE);
}

int 
is_L_select (s)
     char *s;
{

  if (*s == 'L' || *s == 'l')
    return (TRUE);
  else
    return (FALSE);
}

int 
need_89_opcode (insn, result)
     struct pa_it *insn;
     struct pa_89_fp_reg_struct *result;
{
  /* if ( result->L_R_select == 1 || insn->fpof1 == DBL || insn->fpof2 == DBL ) */
  /* if (result->L_R_select == 1 && !(insn->fpof1 == DBL || insn->fpof2 == DBL) ) */
  if (result->L_R_select == 1 && !(insn->fpof1 == DBL && insn->fpof2 == DBL))
    /* if ( insn->fpof1 == DBL || insn->fpof2 == DBL ) */
    return TRUE;
  else
    return FALSE;
}

int
pa_89_parse_number (s, result)
     char **s;
     struct pa_89_fp_reg_struct *result;
{
  int num;
  char *name;
  char c;
  symbolS *sym;
  int status;
  char *p = *s;

  while (*p == ' ' || *p == '\t')
    p = p + 1;
  num = -1;			/* assume invalid number to begin with */
  result->number_part = -1;
  result->L_R_select = -1;

  if (isdigit (*p))
    {
      num = 0;			/* now we know it is a number */

      if (*p == '0' && (*(p + 1) == 'x' || *(p + 1) == 'X'))
	{			/* hex input */
	  p = p + 2;
	  while (isdigit (*p) || ((*p >= 'a') && (*p <= 'f'))
		 || ((*p >= 'A') && (*p <= 'F')))
	    {
	      if (isdigit (*p))
		num = num * 16 + *p - '0';
	      else if (*p >= 'a' && *p <= 'f')
		num = num * 16 + *p - 'a' + 10;
	      else
		num = num * 16 + *p - 'A' + 10;
	      ++p;
	    }
	}
      else
	{
	  while (isdigit (*p))
	    {
	      num = num * 10 + *p - '0';
	      ++p;
	    }
	}

      result->number_part = num;

      if (is_R_select (p))
	{
	  result->L_R_select = 1;
	  ++p;
	}
      else if (is_L_select (p))
	{
	  result->L_R_select = 0;
	  ++p;
	}
      else
	result->L_R_select = 0;

    }
  else if (*p == '%')
    {				/* could be a pre-defined register */
      num = 0;
      name = p;
      p++;
      c = *p;
      /* tege hack: Special case for general registers
       as the general code makes a binary search with case translation,
       and is VERY slow.  */
      if (c == 'r')
	{
	  p++;
	  if (*p == 'e' && *(p + 1) == 't' && (*(p + 2) == '0' || *(p + 2) == '1'))
	    {
	      p += 2;
	      num = *p - '0' + 28;	/* r28 is ret0 */
	      p++;
	    }
	  else if (!isdigit (*p))
	    as_bad ("Undefined register: '%s'. ASSUMING 0", name);
	  else
	    {
	      do
		num = num * 10 + *p++ - '0';
	      while (isdigit (*p));
	    }
	}
      else
	{
	  while (is_part_of_name (c))
	    {
	      p = p + 1;
	      c = *p;
	    }
	  *p = 0;
	  status = reg_name_search (name);
	  if (status >= 0)
	    num = status;
	  else
	    {
	      if (print_errors)
		as_bad ("Undefined register: '%s'. ASSUMING 0", name);
	      else
		num = -1;
	    }
	  *p = c;
	}

      result->number_part = num;

      if (is_R_select (p - 1))
	result->L_R_select = 1;
      else if (is_L_select (p - 1))
	result->L_R_select = 0;
      else
	result->L_R_select = 0;

    }
  else
    {
      num = 0;
      name = p;
      c = *p;
      while (is_part_of_name (c))
	{
	  p = p + 1;
	  c = *p;
	}
      *p = 0;
      if ((sym = symbol_find (name)) != NULL)
	{
#ifdef OBJ_SOM
	  if (sym->pa_sy_type == ST_ABSOLUTE)
	    {
	      num = sym->pa_sy_value;
#else
	  if (S_GET_SEGMENT (sym) == &bfd_abs_section)
	    {
	      num = S_GET_VALUE (sym);
#endif
	    }
	  else
	    {
	      if (print_errors)
		as_bad ("Non-absolute constant: '%s'. ASSUMING 0", name);
	      else
		num = -1;
	    }
	}
      else
	{
	  if (print_errors)
	    as_bad ("Undefined absolute constant: '%s'. ASSUMING 0", name);
	  else
	    num = -1;
	}
      *p = c;
      result->number_part = num;

      if (is_R_select (p - 1))
	result->L_R_select = 1;
      else if (is_L_select (p - 1))
	result->L_R_select = 0;
      else
	result->L_R_select = 0;

    }

  *s = p;
  return num;

}

int 
pa_parse_fp_cmp_cond (s)
     char **s;
{
  int cond, i;
  struct possibleS
    {
      char *string;
      int cond;
    };

  /*
     This table is sorted by order of the length of the string. This is so we
     check for <> before we check for <. If we had a <> and checked for < first,
     we would get a false match.
   */
  static struct possibleS poss[] =
  {
    {"false?", 0},
    {"false", 1},
    {"true?", 30},
    {"true", 31},
    {"!<=>", 3},
    {"!?>=", 8},
    {"!?<=", 16},
    {"!<>", 7},
    {"!>=", 11},
    {"!?>", 12},
    {"?<=", 14},
    {"!<=", 19},
    {"!?<", 20},
    {"?>=", 22},
    {"!?=", 24},
    {"!=t", 27},
    {"<=>", 29},
    {"=t", 5},
    {"?=", 6},
    {"?<", 10},
    {"<=", 13},
    {"!>", 15},
    {"?>", 18},
    {">=", 21},
    {"!<", 23},
    {"<>", 25},
    {"!=", 26},
    {"!?", 28},
    {"?", 2},
    {"=", 4},
    {"<", 9},
    {">", 17}
  };

  cond = 0;

  for (i = 0; i < 32; i++)
    {
      if (strncasecmp (*s, poss[i].string, strlen (poss[i].string)) == 0)
	{
	  cond = poss[i].cond;
	  *s += strlen (poss[i].string);
	  while (**s == ' ' || **s == '\t')
	    *s = *s + 1;
	  return cond;
	}
    }

  as_bad ("Illegal FP Compare Condition: %c", **s);
  return 0;
}

FP_Operand_Format 
pa_parse_fp_format (s)
     char **s;
{
  int f;

  f = SGL;
  if (**s == ',')
    {
      *s += 1;
      if (strncasecmp (*s, "sgl", 3) == 0)
	{
	  f = SGL;
	  *s += 4;
	}
      else if (strncasecmp (*s, "dbl", 3) == 0)
	{
	  f = DBL;
	  *s += 4;
	}
      else if (strncasecmp (*s, "quad", 4) == 0)
	{
	  f = QUAD;
	  *s += 5;
	}
      else
	{
	  f = ILLEGAL_FMT;
	  as_bad ("Unrecognized FP Operand Format: %3s", *s);
	}
    }
  while (**s == ' ' || **s == '\t' || **s == 0)
    *s = *s + 1;

  return f;
}

#if defined(OBJ_ELF)
int 
pa_chk_field_selector (str)
     char **str;
{
  int selector;
  struct selector_entry
    {
      char *prefix;
      int field_selector;
    };
  static struct selector_entry selector_table[] =
  {
    {"F'", e_fsel},
    {"F%", e_fsel},
    {"LS'", e_lssel},
    {"LS%", e_lssel},
    {"RS'", e_rssel},
    {"RS%", e_rssel},
    {"L'", e_lsel},
    {"L%", e_lsel},
    {"R'", e_rsel},
    {"R%", e_rsel},
    {"LD'", e_ldsel},
    {"LD%", e_ldsel},
    {"RD'", e_rdsel},
    {"RD%", e_rdsel},
    {"LR'", e_lrsel},
    {"LR%", e_lrsel},
    {"RR'", e_rrsel},
    {"RR%", e_rrsel},
    {"P'", e_psel},
    {"P%", e_psel},
    {"RP'", e_rpsel},
    {"RP%", e_rpsel},
    {"LP'", e_lpsel},
    {"LP%", e_lpsel},
    {"T'", e_tsel},
    {"T%", e_tsel},
    {"RT'", e_rtsel},
    {"RT%", e_rtsel},
    {"LT'", e_ltsel},
    {"LT%", e_ltsel},
    {NULL, e_fsel}
  };
  struct selector_entry *tableP;

  selector = e_fsel;

  while (**str == ' ' || **str == '\t' || **str == '\n' || **str == '\f')
    {
      *str = *str + 1;
    }
  for (tableP = selector_table; tableP->prefix; tableP++)
    {
      if (strncasecmp (tableP->prefix, *str, strlen (tableP->prefix)) == 0)
	{
	  *str += strlen (tableP->prefix);
	  selector = tableP->field_selector;
	  break;
	}
    }
  return selector;
}

int
getExpression (str)
     char *str;
{
  char *save_in;
  asection *seg;

  save_in = input_line_pointer;
  input_line_pointer = str;
  seg = expression (&the_insn.exp);
  if (!(seg == absolute_section
	|| seg == undefined_section
	|| SEG_NORMAL (seg)))
    {
      the_insn.error = "bad segment";
      expr_end = input_line_pointer;
      input_line_pointer = save_in;
      return 1;
    }
  expr_end = input_line_pointer;
  input_line_pointer = save_in;
  return 0;
}

#else
int
getExpression (str)
     char *str;
{
  char *save_in;
  segT seg;

  save_in = input_line_pointer;
  input_line_pointer = str;
  seg = expression (&the_insn.exp);
  if (!(seg == absolute_section
	|| seg == undefined_section
	|| SEG_NORMAL (seg)))
    {
      the_insn.error = "illegal segment";
      expr_end = input_line_pointer;
      input_line_pointer = save_in;
      return 1;
    }
  expr_end = input_line_pointer;
  input_line_pointer = save_in;
  return 0;
}

#endif

int
getAbsoluteExpression (str)
     char *str;
{
  char *save_in;

  save_in = input_line_pointer;
  input_line_pointer = str;
  expression (&the_insn.exp);
  if (the_insn.exp.X_op != O_constant)
    {
      the_insn.error = "segment should be ABSOLUTE";
      expr_end = input_line_pointer;
      input_line_pointer = save_in;
      return 1;
    }
  expr_end = input_line_pointer;
  input_line_pointer = save_in;
  return 0;
}

int 
evaluateAbsolute (exp, field_selector)
     expressionS exp;
     int field_selector;
{
  int value;

  value = exp.X_add_number;

  switch (field_selector)
    {
    case e_fsel:		/* F  : no change                      */
      break;

    case e_lssel:		/* LS : if (bit 21) then add 0x800
                              arithmetic shift right 11 bits */
      if (value & 0x00000400)
	value += 0x800;
      value = (value & 0xfffff800) >> 11;
      break;

    case e_rssel:		/* RS : Sign extend from bit 21        */
      if (value & 0x00000400)
	value |= 0xfffff800;
      else
	value &= 0x7ff;
      break;

    case e_lsel:		/* L  : Arithmetic shift right 11 bits */
      value = (value & 0xfffff800) >> 11;
      break;

    case e_rsel:		/* R  : Set bits 0-20 to zero          */
      value = value & 0x7ff;
      break;

    case e_ldsel:		/* LD : Add 0x800, arithmetic shift
                              right 11 bits                  */
      value += 0x800;
      value = (value & 0xfffff800) >> 11;
      break;

    case e_rdsel:		/* RD : Set bits 0-20 to one           */
      value |= 0xfffff800;
      break;

    case e_lrsel:		/* LR : L with "rounded" constant      */
      /* XXX: this isn't right.  Need to add a "rounded" constant */
      /* XXX: (presumably from X_add_number)                      */
      value = (value & 0xfffff800) >> 11;
      break;

    case e_rrsel:		/* RR : R with "rounded" constant      */
      /* XXX: this isn't right.  Need to add a "rounded" constant */
      /* XXX: (presumably from X_add_number)                      */
      value = value & 0x7ff;
      break;

    default:
      BAD_CASE (field_selector);
      break;
    }
  return value;
}

int 
pa_build_arg_reloc (type_name)
     char *type_name;
{

  if (strncasecmp (type_name, "no", 2) == 0)
    {
      return 0;
    }
  if (strncasecmp (type_name, "gr", 2) == 0)
    {
      return 1;
    }
  else if (strncasecmp (type_name, "fr", 2) == 0)
    {
      return 2;
    }
  else if (strncasecmp (type_name, "fu", 2) == 0)
    {
      return 3;
    }
  else
    as_bad ("Unrecognized argument location: %s\n", type_name);

  return 0;
}

unsigned int 
pa_align_arg_reloc (reg, arg_reloc)
     unsigned int reg;
     unsigned int arg_reloc;
{
  unsigned int new_reloc;

  new_reloc = arg_reloc;
  switch (reg)
    {
    case 0:
      new_reloc <<= 8;
      break;
    case 1:
      new_reloc <<= 6;
      break;
    case 2:
      new_reloc <<= 4;
      break;
    case 3:
      new_reloc <<= 2;
      break;
    default:
      as_bad ("Illegal argument description: %d", reg);
    }

  return new_reloc;
}

int 
pa_parse_nullif (s)
     char **s;
{
  int nullif;

  nullif = 0;
  if (**s == ',')
    {
      *s = *s + 1;
      if (strncasecmp (*s, "n", 1) == 0)
	nullif = 1;
      else
	{
	  as_bad ("Unrecognized Nullification: (%c)", **s);
	  nullif = 0;
	}
      *s = *s + 1;
    }
  while (**s == ' ' || **s == '\t')
    *s = *s + 1;

  return nullif;
}

int 
pa_parse_nonneg_cmpsub_cmpltr (s, isbranch)
     char **s;
     int isbranch;
{
  int cmpltr;
  char *name = *s + 1;
  char c;
  char *save_s = *s;

  cmpltr = 0;
  if (**s == ',')
    {
      *s += 1;
      while (**s != ',' && **s != ' ' && **s != '\t')
	*s += 1;
      c = **s;
      **s = 0x00;
      if (strcmp (name, "=") == 0)
	{
	  cmpltr = 1;
	}
      else if (strcmp (name, "<") == 0)
	{
	  cmpltr = 2;
	}
      else if (strcmp (name, "<=") == 0)
	{
	  cmpltr = 3;
	}
      else if (strcmp (name, "<<") == 0)
	{
	  cmpltr = 4;
	}
      else if (strcmp (name, "<<=") == 0)
	{
	  cmpltr = 5;
	}
      else if (strcasecmp (name, "sv") == 0)
	{
	  cmpltr = 6;
	}
      else if (strcasecmp (name, "od") == 0)
	{
	  cmpltr = 7;
	}
      /* If we have something like addb,n then there is no condition
	 completer.  */
      else if (strcasecmp (name, "n") == 0 && isbranch)
	{
	  cmpltr = 0;
	}
      else 
	{
	  cmpltr = -1;
	}
      **s = c;
    }
  if (cmpltr >= 0)
    {
      while (**s == ' ' || **s == '\t')
	*s = *s + 1;
    }

  /* Reset pointers if this was really a ,n for a branch instruction.  */
  if (cmpltr == 0 && *name == 'n' && isbranch)
    *s = save_s;

  return cmpltr;
}

int 
pa_parse_neg_cmpsub_cmpltr (s, isbranch)
     char **s;
     int isbranch;
{
  int cmpltr;
  char *name = *s + 1;
  char c;
  char *save_s = *s;

  cmpltr = 0;
  if (**s == ',')
    {
      *s += 1;
      while (**s != ',' && **s != ' ' && **s != '\t')
	*s += 1;
      c = **s;
      **s = 0x00;
      if (strcasecmp (name, "tr") == 0)
	{
	  cmpltr = 0;
	}
      else if (strcmp (name, "<>") == 0)
	{
	  cmpltr = 1;
	}
      else if (strcmp (name, ">=") == 0)
	{
	  cmpltr = 2;
	}
      else if (strcmp (name, ">") == 0)
	{
	  cmpltr = 3;
	}
      else if (strcmp (name, ">>=") == 0)
	{
	  cmpltr = 4;
	}
      else if (strcmp (name, ">>") == 0)
	{
	  cmpltr = 5;
	}
      else if (strcasecmp (name, "nsv") == 0)
	{
	  cmpltr = 6;
	}
      else if (strcasecmp (name, "ev") == 0)
	{
	  cmpltr = 7;
	}
      /* If we have something like addb,n then there is no condition
	 completer.  */
      else if (strcasecmp (name, "n") == 0 && isbranch)
	{
	  cmpltr = 0;
	}
      else
	{
	  cmpltr = -1;
	}
      **s = c;
    }
  if (cmpltr >= 0)
    {
      while (**s == ' ' || **s == '\t')
	*s = *s + 1;
    }

  /* Reset pointers if this was really a ,n for a branch instruction.  */
  if (cmpltr == 0 && *name == 'n' && isbranch)
    *s = save_s;

  return cmpltr;
}

int 
pa_parse_nonneg_add_cmpltr (s, isbranch)
     char **s;
     int isbranch;
{
  int cmpltr;
  char *name = *s + 1;
  char c;
  char *save_s = *s;

  cmpltr = 0;
  if (**s == ',')
    {
      *s += 1;
      while (**s != ',' && **s != ' ' && **s != '\t')
	*s += 1;
      c = **s;
      **s = 0x00;
      if (strcmp (name, "=") == 0)
	{
	  cmpltr = 1;
	}
      else if (strcmp (name, "<") == 0)
	{
	  cmpltr = 2;
	}
      else if (strcmp (name, "<=") == 0)
	{
	  cmpltr = 3;
	}
      else if (strcasecmp (name, "nuv") == 0)
	{
	  cmpltr = 4;
	}
      else if (strcasecmp (name, "znv") == 0)
	{
	  cmpltr = 5;
	}
      else if (strcasecmp (name, "sv") == 0)
	{
	  cmpltr = 6;
	}
      else if (strcasecmp (name, "od") == 0)
	{
	  cmpltr = 7;
	}
      /* If we have something like addb,n then there is no condition
	 completer.  */
      else if (strcasecmp (name, "n") == 0 && isbranch)
	{
	  cmpltr = 0;
	}
      else
	{
	  cmpltr = -1;
	}
      **s = c;
    }
  if (cmpltr >= 0)
    {
      while (**s == ' ' || **s == '\t')
	*s = *s + 1;
    }

  /* Reset pointers if this was really a ,n for a branch instruction.  */
  if (cmpltr == 0 && *name == 'n' && isbranch)
    *s = save_s;

  return cmpltr;
}

int 
pa_parse_neg_add_cmpltr (s, isbranch)
     char **s;
     int isbranch;
{
  int cmpltr;
  char *name = *s + 1;
  char c;
  char *save_s = *s;

  cmpltr = 0;
  if (**s == ',')
    {
      *s += 1;
      while (**s != ',' && **s != ' ' && **s != '\t')
	*s += 1;
      c = **s;
      **s = 0x00;
      if (strcasecmp (name, "tr") == 0)
	{
	  cmpltr = 0;
	}
      else if (strcmp (name, "<>") == 0)
	{
	  cmpltr = 1;
	}
      else if (strcmp (name, ">=") == 0)
	{
	  cmpltr = 2;
	}
      else if (strcmp (name, ">") == 0)
	{
	  cmpltr = 3;
	}
      else if (strcmp (name, "uv") == 0)
	{
	  cmpltr = 4;
	}
      else if (strcmp (name, "vnz") == 0)
	{
	  cmpltr = 5;
	}
      else if (strcasecmp (name, "nsv") == 0)
	{
	  cmpltr = 6;
	}
      else if (strcasecmp (name, "ev") == 0)
	{
	  cmpltr = 7;
	}
      /* If we have something like addb,n then there is no condition
	 completer.  */
      else if (strcasecmp (name, "n") == 0 && isbranch)
	{
	  cmpltr = 0;
	}
      else
	{
	  cmpltr = -1;
	}
      **s = c;
    }
  if (cmpltr >= 0)
    {
      while (**s == ' ' || **s == '\t')
	*s = *s + 1;
    }

  /* Reset pointers if this was really a ,n for a branch instruction.  */
  if (cmpltr == 0 && *name == 'n' && isbranch)
    *s = save_s;

  return cmpltr;
}

void 
s_seg ()
{

  if (strncmp (input_line_pointer, "\"text\"", 6) == 0)
    {
      input_line_pointer += 6;
      s_text (0);
      return;
    }
  if (strncmp (input_line_pointer, "\"data\"", 6) == 0)
    {
      input_line_pointer += 6;
      s_data (0);
      return;
    }
  if (strncmp (input_line_pointer, "\"data1\"", 7) == 0)
    {
      input_line_pointer += 7;
      s_data1 ();
      return;
    }
  as_bad ("Unknown segment type");
  demand_empty_rest_of_line ();
  return;
}

void 
s_private ()
{
  register int temp;

  temp = get_absolute_expression ();
  subseg_set (data_section, (subsegT) temp);
  demand_empty_rest_of_line ();
}

void 
s_data1 ()
{
  subseg_set (data_section, 1);
  demand_empty_rest_of_line ();
  return;
}

void 
s_proc ()
{
  extern char is_end_of_line[];

  while (!is_end_of_line[*input_line_pointer])
    {
      ++input_line_pointer;
    }
  ++input_line_pointer;
  return;
}

void 
pa_block (z)
     int z;
{
  register char *p;
  register long int temp_fill;
  register long int temp_size;
  register int i;

  temp_size = get_absolute_expression ();

  if (z)
    {				/* fill with zeroes even if not requested to do so. */
      temp_fill = 0;		/* HP assembler does this too. */
    }
  else
    {
      temp_fill = 0;
    }

  if (temp_size <= 0)
    {
      as_bad ("size < 0, .block ignored");
      temp_size = 0;
    }
  p = frag_var (rs_fill,
		(int) temp_size,
	(int) temp_size, (relax_substateT) 0, (symbolS *) 0, 1, (char *) 0);
  bzero (p, (int) temp_size);

  /* convert 2 bytes at a time */

  for (i = 0; i < temp_size; i += 2)
    {
      md_number_to_chars (p + i,
			  temp_fill,
			  (int) ((temp_size - i) > 2 ? 2 : (temp_size - i)));
    }

  pa_undefine_label ();
  demand_empty_rest_of_line ();
  return;
}

void 
pa_call ()
{

  pa_call_args (&last_call_desc);
  demand_empty_rest_of_line ();
  return;
}

void 
pa_call_args (call_desc)
     register call_descS *call_desc;
{
  register char *name;
  register char c;
  register char *p;
  register int temp;
  register unsigned int arg_reloc;

  while (!is_end_of_statement ())
    {
      name = input_line_pointer;
      c = get_symbol_end ();
      if ((strncasecmp (name, "argw", 4) == 0))
	{
	  temp = atoi (name + 4);
	  p = input_line_pointer;
	  *p = c;
	  input_line_pointer++;
	  name = input_line_pointer;
	  c = get_symbol_end ();
	  arg_reloc = pa_build_arg_reloc (name);
	  call_desc->arg_reloc |= pa_align_arg_reloc (temp, arg_reloc);
	}
      else if ((strncasecmp (name, "rtnval", 6) == 0))
	{
	  p = input_line_pointer;
	  *p = c;
	  input_line_pointer++;
	  name = input_line_pointer;
	  c = get_symbol_end ();
	  arg_reloc = pa_build_arg_reloc (name);
	  call_desc->arg_reloc |= (arg_reloc & 0x3);
	}
      else
	{
	  as_bad ("Unrecognized .CALL argument: %s", name);
	}
      p = input_line_pointer;
      *p = c;
      if (!is_end_of_statement ())
	input_line_pointer++;
    }
}

static int
is_same_frag (frag1P, frag2P)
     fragS *frag1P;
     fragS *frag2P;
{

  if (frag1P == NULL)
    return (FALSE);
  else if (frag2P == NULL)
    return (FALSE);
  else if (frag1P == frag2P)
    return (TRUE);
  else if (frag2P->fr_type == rs_fill && frag2P->fr_fix == 0)
    return (is_same_frag (frag1P, frag2P->fr_next));
  else
    return (FALSE);
}

#ifdef OBJ_ELF
static void
pa_build_unwind_subspace (call_info)
     call_infoS *call_info;
{
  char *unwindP;
  asection *seg;
  asection *save_seg;
  subsegT subseg, save_subseg;
  int i;
  char c;
  char *p;

  subseg = SUBSEG_UNWIND;
  seg = bfd_get_section_by_name (stdoutput, UNWIND_SECTION_NAME);
  if (seg == ASEC_NULL)
    {
      seg = bfd_make_section_old_way (stdoutput, UNWIND_SECTION_NAME);
    }
  bfd_set_section_flags (stdoutput, seg,
			 (SEC_READONLY | SEC_HAS_CONTENTS
			  | SEC_LOAD | SEC_RELOC));

  /* callinfo.frame is in bytes and unwind_desc is in 8 byte units */
  call_info->ci_unwind.descriptor.frame_size = call_info->frame / 8;

  /* Now, dump the unwind descriptor to the $UNWIND$ subspace. This
     creates a couple of relocations */

  save_seg = now_seg;
  save_subseg = now_subseg;
  subseg_set (seg, subseg);
  unwindP = (char *) &call_info->ci_unwind;

  p = frag_more (4);
  call_info->start_offset_frag = frag_now;
  call_info->start_frag_where = p - frag_now->fr_literal;

  /* relocation info. for start offset of the function */

  fix_new_hppa (frag_now, p - frag_now->fr_literal, 4,
		call_info->start_symbol, (offsetT) 0,
		(expressionS *) NULL, 0, R_HPPA_UNWIND, e_fsel, 32, 0,
		(char *) 0);

  /** we need to search for the first relocation involving the start_symbol of **/
  /** this call_info descriptor **/

  {
    fixS *fixP;

    call_info->start_fix = seg_info (now_seg)->fix_root;	/* the default */
    for (fixP = call_info->start_fix; fixP; fixP = fixP->fx_next)
      {
	if (fixP->fx_addsy == call_info->start_symbol
	    || fixP->fx_subsy == call_info->start_symbol)
	  {
	    call_info->start_fix = fixP;
	    break;
	  }
      }
  }

  p = frag_more (4);
  call_info->end_offset_frag = frag_now;
  call_info->end_frag_where = p - frag_now->fr_literal;

  /* relocation info. for end offset of the function */

  fix_new_hppa (frag_now, p - frag_now->fr_literal, 4,
		call_info->end_symbol, (offsetT) 0,
		(expressionS *) NULL, 0, R_HPPA_UNWIND, e_fsel, 32, 0,
		(char *) 0);

  /** we need to search for the first relocation involving the start_symbol of **/
  /** this call_info descriptor **/

  {
    fixS *fixP;

    call_info->end_fix = seg_info (now_seg)->fix_root;	/* the default */
    for (fixP = call_info->end_fix; fixP; fixP = fixP->fx_next)
      {
	if (fixP->fx_addsy == call_info->end_symbol
	    || fixP->fx_subsy == call_info->end_symbol)
	  {
	    call_info->end_fix = fixP;
	    break;
	  }
      }
  }

  for (i = 8; i < sizeof (unwind_tableS); i++)
    {
      c = *(unwindP + i);
      {
	FRAG_APPEND_1_CHAR (c);
      }
    }

  subseg_set (save_seg, save_subseg);
}

#else
#ifdef OBJ_SOM
static void
pa_build_unwind_subspace (call_info)
     call_infoS *call_info;
{
  space_dict_chainS *spaceP;
  subspace_dict_chainS *subspaceP;
  char *unwindP;
  char defined, loadable, code_only, common, dup_common, is_zero, sort;
  int access, space_index, alignment, quadrant;
  segT seg, save_seg;
  subsegT subseg, save_subseg;
  int i;
  char c;
  char *p;

  defined = 1;
  loadable = 1;
  code_only = 0;
  common = 0;
  dup_common = 0;
  is_zero = 0;
  sort = 0x40;
  access = 0x2c;
  space_index = 0;
  alignment = 8;
  quadrant = 0;
  subseg = SUBSEG_UNWIND;
  seg = SEG_TEXT;

  spaceP = pa_segment_to_space (seg);

  if ((subspaceP = is_defined_subspace ("$UNWIND$", SUBSEG_UNWIND)))
    {
      update_subspace ("$UNWIND$", defined, loadable, code_only, common, dup_common,
		    sort, is_zero, access, space_index, alignment, quadrant,
		       SUBSEG_UNWIND);
    }
  else
    {
      subspaceP = create_new_subspace (spaceP, "$UNWIND$", defined, loadable, code_only,
				  common, dup_common, is_zero, sort, access,
				     space_index, alignment, quadrant, seg);
    }


  /* callinfo.frame is in bytes and unwind_desc is in 8 byte units */
  call_info->ci_unwind.descriptor.frame_size = call_info->frame / 8;

  /* Now, dump the unwind descriptor to the $UNWIND$ subspace. This
     creates a couple of relocations */

  save_seg = now_seg;
  save_subseg = now_subseg;
  subseg_set (seg, subseg);
  unwindP = (char *) &call_info->ci_unwind;

  p = frag_more (4);
  call_info->start_offset_frag = frag_now;
  call_info->start_frag_where = p - frag_now->fr_literal;

  /* relocation info. for start offset of the function */

  fix_new (frag_now, p - frag_now->fr_literal, 4,
	   call_info->start_symbol, (offsetT) 0,
	   (expressionS *) NULL, 0, R_DATA_ONE_SYMBOL, e_fsel, 0, 0,
	   (char *) 0);

  /** we need to search for the first relocation involving the start_symbol of **/
  /** this call_info descriptor **/

  {
    fixS *fixP;

    call_info->start_fix = seg_info (now_seg)->fix_root;	/* the default */
    for (fixP = call_info->start_fix; fixP; fixP = fixP->fx_next)
      {
	/*
      if ( ( fixP->fx_addsy == call_info->start_symbol ||
	     fixP->fx_subsy == call_info->start_symbol )
	  &&
	   ( fixP->fx_frag == call_info->start_symbol->sy_frag ) ) {
       */
	if ((fixP->fx_addsy == call_info->start_symbol ||
	     fixP->fx_subsy == call_info->start_symbol)
	    &&
	    (is_same_frag (fixP->fx_frag, call_info->start_symbol->sy_frag)))
	  {
	    call_info->start_fix = fixP;
	    break;
	  }
      }
  }

  p = frag_more (4);
  call_info->end_offset_frag = frag_now;
  call_info->end_frag_where = p - frag_now->fr_literal;

  /* relocation info. for end offset of the function */

  fix_new (frag_now, p - frag_now->fr_literal, 4,
	   call_info->start_symbol, (offsetT) 0,
	   (expressionS *) NULL, 0, R_DATA_ONE_SYMBOL, e_fsel, 0, 0,
	   (char *) 0);

  /** we need to search for the first relocation involving the start_symbol of **/
  /** this call_info descriptor **/

  {
    fixS *fixP;

    call_info->end_fix = seg_info (now_seg)->fix_root;	/* the default */
    for (fixP = call_info->end_fix; fixP; fixP = fixP->fx_next)
      {
	/*
      if ( ( fixP->fx_addsy == call_info->start_symbol ||
	     fixP->fx_subsy == call_info->start_symbol )
	  &&
	   ( fixP->fx_frag == call_info->start_symbol->sy_frag ) ) {
       */
	if ((fixP->fx_addsy == call_info->start_symbol ||
	     fixP->fx_subsy == call_info->start_symbol)
	    &&
	    (is_same_frag (fixP->fx_frag, call_info->start_symbol->sy_frag)))
	  {
	    call_info->end_fix = fixP;
	    break;
	  }
      }
  }

  for (i = 8; i < sizeof (unwind_tableS); i++)
    {
      c = *(unwindP + i);
      {
	FRAG_APPEND_1_CHAR (c);
      }
    }

  subseg_set (save_seg, save_subseg);

}

#endif
#endif

void 
pa_callinfo ()
{
  register char *name;
  register char c;
  register char *p;
  register int temp;

  if (!within_procedure)
    as_bad (".callinfo is not within a procedure definition");

  callinfo_found = TRUE;

  while (!is_end_of_statement ())
    {
      name = input_line_pointer;
      c = get_symbol_end ();
      if ((strncasecmp (name, "frame", 5) == 0))
	{
	  p = input_line_pointer;
	  *p = c;
	  input_line_pointer++;
	  temp = get_absolute_expression ();
	  if ((temp & 0x3) != 0)
	    {
	      as_bad ("FRAME parameter must be a multiple of 8: %d\n", temp);
	      temp = 0;
	    }
	  last_call_info->frame = temp;
	}
      else if ((strncasecmp (name, "entry_gr", 8) == 0))
	{
	  p = input_line_pointer;
	  *p = c;
	  input_line_pointer++;
	  temp = get_absolute_expression ();
	  last_call_info->ci_unwind.descriptor.entry_gr = temp;
	}
      else if ((strncasecmp (name, "entry_fr", 8) == 0))
	{
	  p = input_line_pointer;
	  *p = c;
	  input_line_pointer++;
	  temp = get_absolute_expression ();
	  last_call_info->ci_unwind.descriptor.entry_fr = temp;
	}
      else if ((strncasecmp (name, "entry_sr", 8) == 0))
	{
	  p = input_line_pointer;
	  *p = c;
	  input_line_pointer++;
	  temp = get_absolute_expression ();
	  last_call_info->entry_sr = temp;
	}
      else if ((strncasecmp (name, "calls", 5) == 0) ||
	       (strncasecmp (name, "caller", 6) == 0))
	{
	  p = input_line_pointer;
	  *p = c;
	  last_call_info->makes_calls = 1;
	}
      else if ((strncasecmp (name, "no_calls", 8) == 0))
	{
	  p = input_line_pointer;
	  *p = c;
	  last_call_info->makes_calls = 0;
	}
      else if ((strncasecmp (name, "save_rp", 7) == 0))
	{
	  p = input_line_pointer;
	  *p = c;
	  last_call_info->ci_unwind.descriptor.save_rp = 1;
	}
      else if ((strncasecmp (name, "save_sp", 7) == 0))
	{
	  p = input_line_pointer;
	  *p = c;
	  last_call_info->ci_unwind.descriptor.save_sp = 1;
	}
      else if ((strncasecmp (name, "no_unwind", 9) == 0))
	{
	  p = input_line_pointer;
	  *p = c;
	  last_call_info->ci_unwind.descriptor.cannot_unwind = 1;
	}
      else if ((strncasecmp (name, "hpux_int", 7) == 0))
	{
	  p = input_line_pointer;
	  *p = c;
	  last_call_info->hpux_int = 1;
	}
      else
	{
	  as_bad ("Unrecognized .CALLINFO argument: %s", name);
	}
      if (!is_end_of_statement ())
	input_line_pointer++;
    }

  demand_empty_rest_of_line ();
  return;
}

void 
pa_code ()
{
  space_dict_chainS *sdchain;

  if ((sdchain = is_defined_space ("$TEXT$")) == NULL)
    {
      sdchain = create_new_space (pa_def_spaces[0].name, pa_def_spaces[0].spnum,
			pa_def_spaces[0].loadable, pa_def_spaces[0].defined,
			    pa_def_spaces[0].private, pa_def_spaces[0].sort,
				  1, pa_def_spaces[0].segment);
    }

  SPACE_DEFINED (sdchain) = 1;

  subseg_set (text_section, SUBSEG_CODE);

  demand_empty_rest_of_line ();
  return;
}

/*
 * This is different than the standard GAS s_comm(). On HP9000/800 machines,
 * the .comm pseudo-op has the following symtax:
 *
 *     <label> .comm <length>
 *
 * where <label> is optional and is a symbol whose address will be the start of
 * a block of memory <length> bytes long. <length> must be an absolute expressio
n.
 * <length> bytes will be allocated in the current space and subspace.
 *
 */

void
pa_comm ()
{
  register int size;
  register symbolS *symbolP;
  register label_symbolS *label_symbolP = pa_get_label ();

  if (label_symbolP)
    symbolP = label_symbolP->lss_label;
  else
    symbolP = NULL;

  SKIP_WHITESPACE ();
  if ((size = get_absolute_expression ()) < 0)
    {
      as_warn (".COMMon length (%d.) <0! Ignored.", size);
      ignore_rest_of_line ();
      return;
    }

  if (symbolP)
    {
#ifdef OBJ_SOM
      if (symbolP->pa_sy_type == ST_STORAGE &&
	  symbolP->pa_sy_scope == SS_UNSAT)
	{
	  if (symbolP->pa_sy_value != size)
	    {
	      as_warn ("Length of .comm \"%s\" is already %d. Not changed to %d.",
		       symbolP->pa_sy_name, symbolP->pa_sy_value, size);
	      return;
	    }
	}
      else
	{
	  symbolP->pa_sy_value = size;
	  symbolP->pa_sy_scope = SS_UNSAT;
	  symbolP->pa_sy_type = ST_STORAGE;
	  symbolP->sy_ref = sym_def;
	}
#endif
#ifdef OBJ_ELF
      if (S_IS_DEFINED (symbolP) && S_GET_SEGMENT (symbolP) == bss_section)
	{
	  as_bad ("Ignoring attempt to re-define symbol");
	  ignore_rest_of_line ();
	  return;
	}
      if (S_GET_VALUE (symbolP))
	{
	  if (S_GET_VALUE (symbolP) != size)
	    {
	      as_warn ("Length of .comm \"%s\" is already %d. Not changed to %d.",
		       S_GET_NAME (symbolP), S_GET_VALUE (symbolP), size);
	      return;
	    }
	}
      else
	{
	  S_SET_VALUE (symbolP, size);
	  S_SET_SEGMENT (symbolP, bss_section);
	  S_SET_EXTERNAL (symbolP);
	}
#endif
    }


  demand_empty_rest_of_line ();
}

void 
pa_copyright ()
{
  register char *name;
  register char c;

  SKIP_WHITESPACE ();
  if (*input_line_pointer == '\"')
    {
      ++input_line_pointer;	/* -> 1st char of string. */
      name = input_line_pointer;
      while ((c = next_char_of_string ()) >= 0)
	;
      c = *input_line_pointer;
      *input_line_pointer = '\0';
      *(input_line_pointer - 1) = '\0';
      {
#ifdef OBJ_SOM
#define PREFIX	"Copyright "
#define MIDFIX  ". All rights reserved. No part of this program may be photocopied, reproduced, or transmitted without prior written consent of "
#define SUFFIX "."

	struct aux_hdr_list *aux_hdr_entry;
	int len;
	char *company_name = name;
	char *date_part;

	date_part = (char *) strchr (name, ',');
	if (date_part)
	  {
	    *date_part = 0x00;
	    date_part++;
	  }

	len =
	  strlen (PREFIX) +
	  strlen (MIDFIX) +
	  strlen (SUFFIX) +
	  2 * strlen (name);

	if (date_part)
	  {
	    len += strlen (date_part) + strlen (",");
	  }

	aux_hdr_entry = (struct aux_hdr_list *) malloc (sizeof (struct aux_hdr_list));
	if (aux_hdr_root)
	  {
	    aux_hdr_entry->ahl_next = aux_hdr_root;
	    aux_hdr_root = aux_hdr_entry;
	  }
	else
	  {
	    aux_hdr_entry->ahl_next = NULL;
	    aux_hdr_root = aux_hdr_entry;
	  }
	aux_hdr_entry->type = COPYRIGHT_AUX_ID;
	aux_hdr_entry->contents.cpy.header_id.append = 1;
	aux_hdr_entry->contents.cpy.header_id.type = COPYRIGHT_AUX_ID;
	aux_hdr_entry->contents.cpy.header_id.length = len + sizeof (unsigned int);
	while (aux_hdr_entry->contents.usr_str.header_id.length % 4)
	  aux_hdr_entry->contents.usr_str.header_id.length += 1;

	aux_hdr_entry->contents.cpy.string_length = len;
	aux_hdr_entry->contents.cpy.copyright = (char *) (malloc (len + 1));
	strcpy (aux_hdr_entry->contents.cpy.copyright, PREFIX);
	strcat (aux_hdr_entry->contents.cpy.copyright, name);
	if (date_part)
	  {
	    strcat (aux_hdr_entry->contents.cpy.copyright, ",");
	    strcat (aux_hdr_entry->contents.cpy.copyright, date_part);
	  }
	strcat (aux_hdr_entry->contents.cpy.copyright, MIDFIX);
	strcat (aux_hdr_entry->contents.cpy.copyright, name);
	strcat (aux_hdr_entry->contents.cpy.copyright, SUFFIX);
	aux_hdr_entry->contents.cpy.copyright[len] = NULL;
#undef PREFIX
#undef MIDFIX
#undef SUFFIX
#endif /* OBJ_SOM */
      }
      *input_line_pointer = c;
    }
  else
    {
      as_bad ("Expected \"-ed string");
    }
  pa_undefine_label ();
  demand_empty_rest_of_line ();
}

void 
pa_end ()
{

  demand_empty_rest_of_line ();
  return;
}

void 
pa_enter ()
{

  as_bad (".ENTER encountered. gas doesn't generate entry code sequences.");
  pa_entry ();
  return;
}

void 
pa_entry ()
{
  char *where;

  if (!within_procedure)
    as_bad ("Misplaced .entry. Ignored.");
  else
    {
      if (!callinfo_found)
	as_bad ("Missing .callinfo.");

      last_call_info->start_frag = frag_now;
    }
  demand_empty_rest_of_line ();
  within_entry_exit = TRUE;
  where = frag_more (0);
#ifdef OBJ_SOM
  fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
		last_call_info->start_symbol, (offsetT) 0,
		(expressionS *) NULL, 0, R_ENTRY, e_fsel, 0, 0,
		(char *) &last_call_info->ci_unwind.descriptor);
#else
#ifdef OBJ_ELF
  /* XXX: no ENTRY relocation for PA ELF.  What do we do instead? */
#else
  fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
		last_call_info->start_symbol, (offsetT) 0,
		(expressionS *) NULL, 0,
		R_HPPA_ENTRY, 0, 0, 0,
		(char *) &last_call_info->ci_unwind.descriptor);
#endif
#endif
  return;
}

void 
pa_equ (reg)
     int reg;
{
  register label_symbolS *label_symbolP = pa_get_label ();
  register symbolS *symbolP;

  if (label_symbolP)
    {
      symbolP = label_symbolP->lss_label;
#ifdef OBJ_SOM
      symbolP->pa_sy_value = get_absolute_expression ();
      symbolP->pa_sy_type = ST_ABSOLUTE;
      symbolP->sy_ref = sym_unref;
      symbolP->sy_equ = 1;
#else
      S_SET_VALUE (symbolP, get_absolute_expression ());
      S_SET_SEGMENT (symbolP, &bfd_abs_section);
#endif
    }
  else
    {
      if (reg)
	as_bad (".REG must use a label");
      else
	as_bad (".EQU must use a label");
    }

  pa_undefine_label ();
  demand_empty_rest_of_line ();
  return;
}

void 
process_exit ()
{
  char *where;

  where = frag_more (0);
#ifdef OBJ_SOM
  fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
		last_call_info->start_symbol, (offsetT) 0,
		(expressionS *) NULL, 0, R_EXIT, e_fsel, 0, 0,
		(char *) NULL);
#endif
#ifdef OBJ_ELF
  /* XXX: no EXIT relocation for PA ELF.  All we do is create a */
  /* temporary symbol marking the end of the function. */
  {
    char *name = (char *) xmalloc (strlen ("L\001end_") +
		    strlen (S_GET_NAME (last_call_info->start_symbol)) + 1);

    if (name)
      {
	symbolS *symbolP;

	strcpy (name, "L\001end_");
	strcat (name, S_GET_NAME (last_call_info->start_symbol));

	symbolP = symbol_find (name);
	if (symbolP)
	  as_warn ("Symbol '%s' already defined.", name);
	else
	  {
	    /* symbol value should be the offset of the */
	    /* last instruction of the function */
	    symbolP = symbol_new (name,
				  now_seg,
	    (valueT) (obstack_next_free (&frags) - frag_now->fr_literal - 4),
				  frag_now);

	    assert (symbolP);

	    symbolP->bsym->flags = BSF_LOCAL;
	    symbol_table_insert (symbolP);
	  }
	if (symbolP)
	  last_call_info->end_symbol = symbolP;
	else
	  as_bad ("Symbol '%s' could not be created.", name);

      }
    else
      as_bad ("No memory for symbol name.");
  }
#else
  fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
		last_call_info->start_symbol, (offsetT) 0,
		(expressionS *) NULL, 0, R_HPPA_EXIT, 0, 0, 0,
		(char *) NULL);
#endif
  last_call_info->end_frag = frag_now;

  pa_build_unwind_subspace (last_call_info);

  exit_processing_complete = TRUE;
}

void 
pa_exit ()
{

  if (!within_procedure)
    as_bad (".EXIT must appear within a procedure");
  else
    {
      if (!callinfo_found)
	as_bad ("Missing .callinfo");
      else
	{
	  if (!within_entry_exit)
	    as_bad ("No .ENTRY for this .EXIT");
	  else
	    {
	      within_entry_exit = FALSE;
	      process_exit ();
	    }
	}
    }
  demand_empty_rest_of_line ();
  return;
}

#ifdef OBJ_ELF
void
  pa_build_symextn_section()
{
  segT seg;
  asection *save_seg = now_seg;
  subsegT subseg = (subsegT)0;
  subsegT save_subseg = now_subseg;

  seg = subseg_new(".hppa_symextn", subseg);
  bfd_set_section_flags (stdoutput,
			 seg,
			 SEC_HAS_CONTENTS | SEC_READONLY | SEC_ALLOC | SEC_LOAD);

  subseg_set(save_seg, save_subseg);
  
}
#endif

void 
pa_export ()
{
  register char *name;
  register char c;
  register char *p;
  register symbolS *symbolP;

  name = input_line_pointer;
  c = get_symbol_end ();
  /* just after name is now '\0' */

  if ((symbolP = symbol_find_or_make (name)) == NULL)
    {
      as_bad ("Cannot define export symbol: %s\n", name);
      p = input_line_pointer;
      *p = c;
      input_line_pointer++;
    }
  else
    {
#ifdef OBJ_SOM
      symbolP->pa_sy_dict.symbol_scope = SS_UNIVERSAL;
      /* determination of the symbol_type field will have to wait until
	 we know the subspace index (within the object file) of the subspace
	 containing this symbol */
#else
      /* S_SET_SEGMENT(symbolP,&bfd_und_section); */
      S_SET_EXTERNAL (symbolP);
      /* symbolP->sy_frag = frag_now; */
#endif

      p = input_line_pointer;
      *p = c;
      if (!is_end_of_statement ())
	{
	  input_line_pointer++;
	  pa_export_args (symbolP);
#ifdef OBJ_ELF
	  pa_build_symextn_section();
#endif
	}
    }

  demand_empty_rest_of_line ();
  return;
}

void 
pa_export_args (symbolP)
     register symbolS *symbolP;
{
  register char *name;
  register char c;
  register char *p;
  register int temp;
  register unsigned int arg_reloc;
#ifdef OBJ_ELF
  elf32_symbol_type *esymbolP = (elf32_symbol_type *) (symbolP->bsym);
#endif

  if (strncasecmp (input_line_pointer, "absolute", 8) == 0)
    {
      input_line_pointer += 8;
#ifdef OBJ_SOM
      symbolP->pa_sy_dict.symbol_type = ST_ABSOLUTE;
#else
      S_SET_SEGMENT (symbolP, &bfd_abs_section);
#endif
    }
  else if (strncasecmp (input_line_pointer, "code", 4) == 0)
    {
      input_line_pointer += 4;
#ifdef OBJ_SOM
      symbolP->pa_sy_dict.symbol_type = ST_CODE;
#else
      /* S_SET_SEGMENT(symbolP,text_section); */
#endif
    }
  else if (strncasecmp (input_line_pointer, "data", 4) == 0)
    {
      input_line_pointer += 4;
#ifdef OBJ_SOM
      symbolP->pa_sy_dict.symbol_type = ST_DATA;
#else
      /* S_SET_SEGMENT(symbolP,data_section); */
#endif
    }
  else if ((strncasecmp (input_line_pointer, "entry", 5) == 0))
    {
      input_line_pointer += 5;
#ifdef OBJ_SOM
      symbolP->pa_sy_dict.symbol_type = ST_ENTRY;
#else
      symbolP->bsym->flags |= BSF_FUNCTION;
#endif
    }
  else if (strncasecmp (input_line_pointer, "millicode", 9) == 0)
    {
      input_line_pointer += 9;
#ifdef OBJ_SOM
      symbolP->pa_sy_dict.symbol_type = ST_MILLICODE;
#endif
    }
  else if (strncasecmp (input_line_pointer, "plabel", 6) == 0)
    {
      input_line_pointer += 6;
#ifdef OBJ_SOM
      symbolP->pa_sy_dict.symbol_type = ST_PLABEL;
#endif
    }
  else if (strncasecmp (input_line_pointer, "pri_prog", 8) == 0)
    {
      input_line_pointer += 8;
#ifdef OBJ_SOM
      symbolP->pa_sy_dict.symbol_type = ST_PRI_PROG;
#endif
    }
  else if (strncasecmp (input_line_pointer, "sec_prog", 8) == 0)
    {
      input_line_pointer += 8;
#ifdef OBJ_SOM
      symbolP->pa_sy_dict.symbol_type = ST_SEC_PROG;
#endif
    }

  while (!is_end_of_statement ())
    {
      if (*input_line_pointer == ',')
	input_line_pointer++;
      name = input_line_pointer;
      c = get_symbol_end ();
      if ((strncasecmp (name, "argw", 4) == 0))
	{
	  p = input_line_pointer;
	  *p = c;
	  input_line_pointer++;
	  temp = atoi (name + 4);
	  name = input_line_pointer;
	  c = get_symbol_end ();
	  arg_reloc = pa_align_arg_reloc (temp, pa_build_arg_reloc (name));
#ifdef OBJ_SOM
	  symbolP->pa_sy_dict.arg_reloc |= arg_reloc;
#else
	  esymbolP->tc_data.hppa_arg_reloc |= arg_reloc;
#endif
	  *input_line_pointer = c;
	}
      else if ((strncasecmp (name, "rtnval", 6)) == 0)
	{
	  p = input_line_pointer;
	  *p = c;
	  input_line_pointer++;
	  name = input_line_pointer;
	  c = get_symbol_end ();
	  arg_reloc = pa_build_arg_reloc (name);
#ifdef OBJ_SOM
	  symbolP->pa_sy_dict.arg_reloc |= arg_reloc;
#else
	  esymbolP->tc_data.hppa_arg_reloc |= arg_reloc;
#endif
	  *input_line_pointer = c;
	}
      else if ((strncasecmp (name, "priv_lev", 8)) == 0)
	{
	  p = input_line_pointer;
	  *p = c;
	  input_line_pointer++;
	  /*** temp = get_absolute_expression (); ***/
	  temp = atoi (input_line_pointer);
	  c = get_symbol_end ();
	  *input_line_pointer = c;
#ifdef OBJ_SOM
	  symbolP->sy_priv_lev = temp & 3;	/* this is stored in symbol_value later */
#endif
	}
      else
	{
	  as_bad ("Undefined .EXPORT/.IMPORT argument (ignored): %s", name);
	  p = input_line_pointer;
	  *p = c;
	}
      if (!is_end_of_statement ())
	input_line_pointer++;
    }
}

void 
pa_import ()
{
  register char *name;
  register char c;
  register char *p;
  register symbolS *symbolP;

  name = input_line_pointer;
  c = get_symbol_end ();
  /* just after name is now '\0' */

  symbolP = symbol_find_or_make (name);
#if defined(OBJ_ELF)
  /* symbolP->bsym->flags |= BSF_IMPORT; *//* XXX BSF_IMPORT is obsolete */
#else
  /* Check to see if this symbol has already been exported (this means its */
  /* defined locally and the import statement is redundant). */
  /* If it has not been exported, go ahead and mark this symbol as SS_UNSAT */
  /* (an unsatisfied external symbol) */

  /* But, if the symbol has already been referenced (sy_ref == TRUE),
       leave it alone. */

  if (!symbolP->sy_ref)
    {
      if (symbolP->pa_sy_dict.symbol_scope != SS_UNIVERSAL)
	{
	  symbolP->pa_sy_dict.symbol_scope = SS_UNSAT;
	  symbolP->sy_ref = FALSE;
	}
    }
#endif

  p = input_line_pointer;
  *p = c;

  if (!is_end_of_statement ())
    {
      input_line_pointer++;

      pa_export_args (symbolP);
#ifdef OBJ_ELF
      /* In ELF, since this is an import, leave the section undefined.	*/
      /* S_SET_SEGMENT(symbolP,&bfd_und_section); */
#endif
    }
  else
    {
#ifdef OBJ_SOM
      /* no further arguments, assign a default type according
	       to the current subspace (CODE or DATA) */
      switch (now_seg)
	{
	case SEG_TEXT:
	  symbolP->pa_sy_dict.symbol_type = ST_CODE;
	  break;
	case SEG_ABSOLUTE:
	  symbolP->pa_sy_dict.symbol_type = ST_ABSOLUTE;
	  break;
	default:
	  symbolP->pa_sy_dict.symbol_type = ST_DATA;
	}
#else
      /* In ELF, if the section is undefined, then the symbol is undefined */
      /* Since this is an import, leave the section undefined.	*/
      S_SET_SEGMENT (symbolP, &bfd_und_section);
#endif
    }


  demand_empty_rest_of_line ();
  return;
}

void 
pa_label ()
{
  register char *name;
  register char c;
  register char *p;

  name = input_line_pointer;
  c = get_symbol_end ();
  /* just after name is now '\0' */

  if (strlen (name) > 0)
    {
      colon (name);
      p = input_line_pointer;
      *p = c;
    }
  else
    {
      as_warn ("Missing label name on .LABEL");
    }

  if (!is_end_of_statement ())
    {
      as_warn ("extra .LABEL arguments ignored.");
      ignore_rest_of_line ();
    }
  demand_empty_rest_of_line ();
  return;
}

void 
pa_leave ()
{

  as_bad (".LEAVE encountered. gas doesn't generate exit code sequences.");
  pa_exit ();
  return;
}

void 
pa_origin ()
{
  s_org (0);			/* ORG actually allows another argument
				   (the fill value) but maybe this is OK? */
  pa_undefine_label ();
  return;
}


void 
pa_param ()
{
  char *name;
  char c;
  char *p;
  symbolS *symbolP;

  name = input_line_pointer;
  c = get_symbol_end ();
  /* just after name is now '\0' */

  if ((symbolP = symbol_find_or_make (name)) == NULL)
    {
      as_bad ("Cannot define static symbol: %s\n", name);
      p = input_line_pointer;
      *p = c;
      input_line_pointer++;
    }
  else
    {
#ifdef OBJ_SOM
      symbolP->pa_sy_dict.symbol_scope = SS_LOCAL;
      /* determination of the symbol_type field will have to wait until
	 we know the subspace index (within the object file) of the subspace
	 containing this symbol */
#else
      /* S_SET_SEGMENT(symbolP,&bfd_und_section); */
      S_CLEAR_EXTERNAL (symbolP);
      /* symbolP->sy_frag = frag_now; */
#endif

      p = input_line_pointer;
      *p = c;
      if (!is_end_of_statement ())
	{
	  input_line_pointer++;
	  pa_export_args (symbolP);
	}
    }

  demand_empty_rest_of_line ();
  return;
}

void 
pa_proc ()
{
  call_infoS *call_info;

  if (within_procedure)
    as_fatal ("Nested procedures");

  callinfo_found = FALSE;
  within_procedure = TRUE;
  exit_processing_complete = FALSE;

  /* create another call_info structure */

  call_info = (call_infoS *) xmalloc (sizeof (call_infoS));

  if (!call_info)
    as_fatal ("Cannot allocate unwind descriptor\n");

  bzero (call_info, sizeof (call_infoS));

  call_info->ci_next = NULL;

  if (call_info_root == NULL)
    {
      call_info_root = call_info;
      last_call_info = call_info;
    }
  else
    {
      last_call_info->ci_next = call_info;
      last_call_info = call_info;
    }

  /* set up defaults on call_info structure */

  call_info->ci_unwind.descriptor.cannot_unwind = 0;
  call_info->ci_unwind.descriptor.region_desc = 1;
  call_info->entry_sr = ~0;
  call_info->makes_calls = 1;
  call_info->hpux_int = 0;

  /* If we got a .PROC pseudo-op, we know that the function is defined
     locally. Make sure it gets into the symbol table */
  {
    label_symbolS *label_symbolP = pa_get_label ();

    if (label_symbolP)
      {
	if (label_symbolP->lss_label)
	  {
#ifdef OBJ_SOM
	    label_symbolP->lss_label->sy_ref |= sym_def;
#endif
	    last_call_info->start_symbol = label_symbolP->lss_label;
	    label_symbolP->lss_label->bsym->flags |= BSF_FUNCTION;
	  }
	else
	  as_bad ("Missing function name for .PROC (corrupted label)");
      }
    else
      as_bad ("Missing function name for .PROC");
  }

  demand_empty_rest_of_line ();
  return;
}

void 
pa_procend ()
{

  if (!within_procedure)
    as_bad ("misplaced .procend");

  if (!callinfo_found)
    as_bad ("Missing .callinfo for this procedure");

  if (within_entry_exit)
    as_bad ("Missing .EXIT for a .ENTRY");

  if (!exit_processing_complete)
    process_exit ();

  within_procedure = FALSE;
  demand_empty_rest_of_line ();
  return;
}

space_dict_chainS *
pa_parse_space_stmt (space_name, create_flag)
     char *space_name;
     int create_flag;
{
  register char *name;
  register char c;
  register char *p;
  register int temp;

  char *ptemp;
  int spnum;
  char loadable;
  char defined;
  char private;
  char sort;
#ifdef OBJ_SOM
  segT seg;
#else
  asection *seg;
#endif
  space_dict_chainS *space;

  /* load default values */
  spnum = 0;
  loadable = TRUE;
  defined = TRUE;
  private = FALSE;
  if (strcasecmp (space_name, "$TEXT$") == 0)
    {
#ifdef OBJ_SOM
      seg = SEG_TEXT;
#else
      seg = text_section;
#endif
      sort = 8;
    }
  else
    {
#ifdef OBJ_SOM
      seg = SEG_DATA;
#else
      seg = data_section;
#endif
      sort = 16;
    }

  if (!is_end_of_statement ())
    {
      print_errors = FALSE;
      ptemp = input_line_pointer + 1;
      if ((temp = pa_parse_number (&ptemp)) >= 0)
	{
	  spnum = temp;
	  input_line_pointer = ptemp;
	}
      else
	{
	  while (!is_end_of_statement ())
	    {
	      input_line_pointer++;
	      name = input_line_pointer;
	      c = get_symbol_end ();
	      if ((strncasecmp (name, "SPNUM", 5) == 0))
		{
		  p = input_line_pointer;
		  *p = c;
		  input_line_pointer++;
		  temp = get_absolute_expression ();
		  spnum = temp;
		}
	      else if ((strncasecmp (name, "SORT", 4) == 0))
		{
		  p = input_line_pointer;
		  *p = c;
		  input_line_pointer++;
		  temp = get_absolute_expression ();
		  sort = temp;
		}
	      else if ((strncasecmp (name, "UNLOADABLE", 10) == 0))
		{
		  p = input_line_pointer;
		  *p = c;
		  loadable = FALSE;
		}
	      else if ((strncasecmp (name, "NOTDEFINED", 10) == 0))
		{
		  p = input_line_pointer;
		  *p = c;
		  defined = FALSE;
		}
	      else if ((strncasecmp (name, "PRIVATE", 7) == 0))
		{
		  p = input_line_pointer;
		  *p = c;
		  private = TRUE;
		}
	      else
		{
		  as_bad ("Unrecognized .SPACE argument");
		  p = input_line_pointer;
		  *p = c;
		}
	    }
	}
      print_errors = TRUE;
    }
  if (create_flag)
    space = create_new_space (space_name, spnum, loadable, defined, private, sort, 1, seg);
  else
    {				/* if no creation of new space, this must be the first */
      /* occurrence of a built-in space */
      space = is_defined_space (space_name);
      SPACE_SPNUM (space) = spnum;
      SPACE_LOADABLE (space) = loadable & 1;
      SPACE_DEFINED (space) = defined & 1;
      SPACE_PRIVATE (space) = private & 1;
      SPACE_SORT (space) = sort & 0xff;
      space->sd_defined = 1;
      space->sd_seg = seg;
    }
  return space;
}

void 
pa_align_subseg (seg, subseg)
     segT seg;
     subsegT subseg;
{
  subspace_dict_chainS *now_subspace;
  int alignment;
  int shift;

  now_subspace = pa_subsegment_to_subspace (seg, subseg);
  if (SUBSPACE_ALIGN (now_subspace) == 0)
    alignment = now_subspace->ssd_last_align;
  else if (now_subspace->ssd_last_align > SUBSPACE_ALIGN (now_subspace))
    alignment = now_subspace->ssd_last_align;
  else
    alignment = SUBSPACE_ALIGN (now_subspace);

  shift = 0;
  while ((1 << shift) < alignment)
    shift++;

  frag_align (shift, 0);
}

void 
pa_space ()
{
  register char *name;
  register char c;
  register int temp;
  register space_dict_chainS *sd_chain;
  char space_name[40];

  if (within_procedure)
    {
      as_bad ("Can\'t change spaces within a procedure definition. Ignored");
      ignore_rest_of_line ();
    }
  else
    {
      if (strncasecmp (input_line_pointer, "$text$", 6) == 0)
	{
	  input_line_pointer += 6;
	  sd_chain = is_defined_space ("$TEXT$");
	  if (sd_chain == NULL)
	    sd_chain = pa_parse_space_stmt ("$TEXT$", 1);
	  else if (sd_chain->sd_defined == 0)
	    sd_chain = pa_parse_space_stmt ("$TEXT$", 0);

	  current_space = sd_chain;
	  SPACE_DEFINED (current_space) = 1;
	  current_space->sd_defined = 1;
	  if (now_seg != text_section)	/* no need to align if we are already there */
	    pa_align_subseg (now_seg, now_subseg);

	  subseg_set (text_section, sd_chain->sd_last_subseg);
	  current_subspace = pa_subsegment_to_subspace (text_section,
						  sd_chain->sd_last_subseg);
	  demand_empty_rest_of_line ();
	  return;
	}
      if (strncasecmp (input_line_pointer, "$private$", 9) == 0)
	{
	  input_line_pointer += 9;
	  sd_chain = is_defined_space ("$PRIVATE$");
	  if (sd_chain == NULL)
	    sd_chain = pa_parse_space_stmt ("$PRIVATE$", 1);
	  else if (sd_chain->sd_defined == 0)
	    sd_chain = pa_parse_space_stmt ("$PRIVATE$", 0);

	  current_space = sd_chain;
	  SPACE_DEFINED (current_space) = 1;
	  current_space->sd_defined = 1;
	  if (now_seg != data_section)	/* no need to align if we are already there */
	    pa_align_subseg (now_seg, now_subseg);
	  subseg_set (data_section, sd_chain->sd_last_subseg);
	  current_subspace = pa_subsegment_to_subspace (data_section,
						  sd_chain->sd_last_subseg);
	  demand_empty_rest_of_line ();
	  return;
	}
      if (strncasecmp (input_line_pointer,
		  GDB_DEBUG_SPACE_NAME, strlen (GDB_DEBUG_SPACE_NAME)) == 0)
	{
	  input_line_pointer += strlen (GDB_DEBUG_SPACE_NAME);
	  sd_chain = is_defined_space (GDB_DEBUG_SPACE_NAME);
	  if (sd_chain == NULL)
	    sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 1);
	  else if (sd_chain->sd_defined == 0)
	    sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 0);

	  current_space = sd_chain;
	  SPACE_DEFINED (current_space) = 1;
	  current_space->sd_defined = 1;

#ifdef OBJ_SOM
	  if (now_seg != SEG_GDB)  /* no need to align if we are already there */

	    pa_align_subseg (now_seg, now_subseg);
	  subseg_set (SEG_GDB, sd_chain->sd_last_subseg);
	  current_subspace = pa_subsegment_to_subspace (SEG_GDB,
						  sd_chain->sd_last_subseg);
#else
	  {
	    segT gdb_section;
	    /* no need to align if we are already there */
	    if (strcmp (segment_name (now_seg), GDB_DEBUG_SPACE_NAME) != 0)
	      pa_align_subseg (now_seg, now_subseg);
	    gdb_section = subseg_new (GDB_DEBUG_SPACE_NAME,
				      sd_chain->sd_last_subseg);
	    current_subspace = pa_subsegment_to_subspace (gdb_section,
							  sd_chain->sd_last_subseg);
	  }
#endif
	  demand_empty_rest_of_line ();
	  return;
	}

      /* it could be a space specified by number */

      if ((temp = pa_parse_number (&input_line_pointer)) >= 0)
	{
	  if (sd_chain = pa_find_space_by_number (temp))
	    {
	      current_space = sd_chain;
	      SPACE_DEFINED (current_space) = 1;
	      current_space->sd_defined = 1;
	      if (now_seg != sd_chain->sd_seg)	/* don't align if we're already there */
		pa_align_subseg (now_seg, now_subseg);
	      subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
	      current_subspace = pa_subsegment_to_subspace (sd_chain->sd_seg,
						  sd_chain->sd_last_subseg);
	      demand_empty_rest_of_line ();
	      return;
	    }
	}

      /* not a number, attempt to create a new space */

      name = input_line_pointer;
      c = get_symbol_end ();
      space_name[0] = 0x00;
      strcpy (space_name, name);
      *input_line_pointer = c;

      sd_chain = pa_parse_space_stmt (space_name, 1);
      current_space = sd_chain;
      SPACE_DEFINED (current_space) = 1;
      current_space->sd_defined = 1;
      if (now_seg != sd_chain->sd_seg)	/* don't align if we're already there */
	pa_align_subseg (now_seg, now_subseg);
      subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
      current_subspace = pa_subsegment_to_subspace (sd_chain->sd_seg,
						  sd_chain->sd_last_subseg);
      demand_empty_rest_of_line ();
    }
  return;
}

void 
pa_spnum ()
{
  register char *name;
  register char c;
  register char *p;
  space_dict_chainS *space;

  name = input_line_pointer;
  c = get_symbol_end ();
  space = is_defined_space (name);
  if (space)
    {
      p = frag_more (4);
      /* put bytes in right order. */
      md_number_to_chars (p, SPACE_SPNUM (space), 4);
    }
  else
    as_warn ("Undefined space: '%s' Assuming space number = 0.", name);

  *input_line_pointer = c;
  demand_empty_rest_of_line ();
  return;
}

static
int 
is_power_of_2 (value)
     int value;
{
  int shift;

  shift = 0;
  while ((1 << shift) != value && shift < 32)
    shift++;

  if (shift >= 32)
    shift = 0;
  return shift;
}

void 
pa_subspace ()
{
  register char *name;
  register char c;
  register int temp;
  char loadable, code_only, common, dup_common, zero;
  char sort;
  int i;
  int access;
  int space_index;
  int alignment;
  int quadrant;
  space_dict_chainS *space;
  subspace_dict_chainS *ssd;
  char *ss_name;
  int is_power_of_2 ();

  if (within_procedure)
    {
      as_bad ("Can\'t change subspaces within a procedure definition. Ignored");
      ignore_rest_of_line ();
    }
  else
    {
      name = input_line_pointer;
      c = get_symbol_end ();
      space = pa_segment_to_space (now_seg);
      ssd = is_defined_subspace (name, space->sd_last_subseg);

      ss_name = xmalloc (strlen (name) + 1);
      strcpy (ss_name, name);

      *input_line_pointer = c;

      /* load default values */
      sort = 0;
      access = 0x7f;
      loadable = 1;
      common = 0;
      dup_common = 0;
      code_only = 0;
      zero = 0;
      space_index = ~0;		/* filled in when the .o file is written */
      alignment = 0;		/* alignment=0 means no ALIGN= appeared on the .SUBSPA */
      /* pseudo-op. The default will be the largest .ALIGN */
      /* encountered (or 1 if no .ALIGN is encountered) */
      quadrant = 0;

      if (ssd)
	{
	  if (ssd->ssd_defined)
	    {
#ifdef OBJ_SOM
	      subseg_set (now_seg, ssd->ssd_subseg);
#else
	      /* subseg_new(now_seg->name,ssd->ssd_subseg); */
	      subseg_new ((char *) ssd->ssd_seg->name, ssd->ssd_subseg);
#endif
	      if (!is_end_of_statement ())
		{
		  as_warn ("Parameters of an existing subspace can\'t be modified");
		}
	      demand_empty_rest_of_line ();
	      return;
	    }
	  else
	    {
	      ssd->ssd_defined = 1;
	    }
	}
      else
	{
	  /* a new subspace */
	  /* load default values */
	  i = 0;
	  while (pa_def_subspaces[i].name)
	    {
	      if (strcasecmp (pa_def_subspaces[i].name, ss_name) == 0)
		{
		  loadable = pa_def_subspaces[i].loadable;
		  common = pa_def_subspaces[i].common;
		  dup_common = pa_def_subspaces[i].dup_common;
		  code_only = pa_def_subspaces[i].code_only;
		  zero = pa_def_subspaces[i].zero;
		  space_index = pa_def_subspaces[i].space_index;
		  /* alignment = pa_def_subspaces[i].alignment; */
		  alignment = 0;
		  quadrant = pa_def_subspaces[i].quadrant;
		  access = pa_def_subspaces[i].access;
		  sort = pa_def_subspaces[i].sort;
		  break;
		}
	      i++;
	    }
	}

      if (!is_end_of_statement ())
	{
	  input_line_pointer++;
	  while (!is_end_of_statement ())
	    {
	      name = input_line_pointer;
	      c = get_symbol_end ();
	      if ((strncasecmp (name, "QUAD", 4) == 0))
		{
		  *input_line_pointer = c;
		  input_line_pointer++;
		  temp = get_absolute_expression ();
		  quadrant = temp;
		}
	      else if ((strncasecmp (name, "ALIGN", 5) == 0))
		{
		  *input_line_pointer = c;
		  input_line_pointer++;
		  temp = get_absolute_expression ();
		  alignment = temp;
		  if (!is_power_of_2 (alignment))
		    {
		      as_bad ("Alignment must be a power of 2");
		      alignment = 1;
		    }
		}
	      else if ((strncasecmp (name, "ACCESS", 6) == 0))
		{
		  *input_line_pointer = c;
		  input_line_pointer++;
		  temp = get_absolute_expression ();
		  access = temp;
		}
	      else if ((strncasecmp (name, "SORT", 4) == 0))
		{
		  *input_line_pointer = c;
		  input_line_pointer++;
		  temp = get_absolute_expression ();
		  sort = temp;
		}
	      else if ((strncasecmp (name, "CODE_ONLY", 9) == 0))
		{
		  *input_line_pointer = c;
		  code_only = 1;
		}
	      else if ((strncasecmp (name, "UNLOADABLE", 10) == 0))
		{
		  *input_line_pointer = c;
		  loadable = 0;
		}
	      else if ((strncasecmp (name, "COMMON", 6) == 0))
		{
		  *input_line_pointer = c;
		  common = 1;
		}
	      else if ((strncasecmp (name, "DUP_COMM", 8) == 0))
		{
		  *input_line_pointer = c;
		  dup_common = 1;
		}
	      else if ((strncasecmp (name, "ZERO", 4) == 0))
		{
		  *input_line_pointer = c;
		  zero = 1;
		}
	      else
		{
		  as_bad ("Unrecognized .SUBSPACE argument");
		}
	      if (!is_end_of_statement ())
		input_line_pointer++;
	    }
	}
      space = pa_segment_to_space (now_seg);
      if (ssd)
	{
	  current_subspace = update_subspace (ss_name, 1, loadable, code_only,
				     common, dup_common, sort, zero, access,
					   space_index, alignment, quadrant,
					      ssd->ssd_subseg);
	}
      else
	{
	  current_subspace = create_new_subspace (space, ss_name, 1, loadable, code_only,
					     common, dup_common, zero, sort,
					     access, space_index, alignment,
						  quadrant, now_seg);
	}
      SUBSPACE_SUBSPACE_START (current_subspace) = pa_subspace_start (space, quadrant);

      demand_empty_rest_of_line ();
      subseg_set (current_subspace->ssd_seg, current_subspace->ssd_subseg);
    }
  return;
}

/* For ELF, this function serves one purpose:  to setup the st_size	*/
/* field of STT_FUNC symbols.  To do this, we need to scan the 		*/
/* call_info structure list, determining st_size in one of two possible	*/
/* ways:								*/

/*	1. call_info->start_frag->fr_fix has the size of the fragment.	*/
/*	   This approach assumes that the function was built into a 	*/
/*	   single fragment.  This works for most cases, but might fail.	*/
/*	   For example, if there was a segment change in the middle of	*/
/*	   the function.						*/

/*	2. The st_size field is the difference in the addresses of the	*/
/*	   call_info->start_frag->fr_address field and the fr_address	*/
/*	   field of the next fragment with fr_type == rs_fill and	*/
/*	   fr_fix != 0.							*/

void 
elf_hppa_final_processing ()
{
  extern call_infoS *call_info_root;

  call_infoS *ciP;

  for (ciP = call_info_root; ciP; ciP = ciP->ci_next)
    {
      elf32_symbol_type *esym = (elf32_symbol_type *) ciP->start_symbol->bsym;
      esym->internal_elf_sym.st_size =
	S_GET_VALUE (ciP->end_symbol) - S_GET_VALUE (ciP->start_symbol) + 4;
    }
}

/* pa-spaces.c -- Space/subspace support for the HP PA-RISC version of GAS */

/* for space, subspace, and symbol maintenance on HP 9000 Series 800 */

space_dict_chainS *space_dict_root;
space_dict_chainS *space_dict_last;

space_dict_chainS *current_space;
subspace_dict_chainS *current_subspace;

void 
pa_spaces_begin ()
{
  space_dict_chainS *space;
  int i;
  subsegT now_subseg = now_subseg;

  space_dict_root = NULL;
  space_dict_last = NULL;

  /* create default space and subspace dictionaries */

  i = 0;
  while (pa_def_spaces[i].name)
    {
      if (pa_def_spaces[i].alias)
	pa_def_spaces[i].segment = subseg_new (pa_def_spaces[i].alias, 0);
      else
	pa_def_spaces[i].segment = bfd_make_section_old_way (stdoutput, pa_def_spaces[i].name);

      create_new_space (pa_def_spaces[i].name, pa_def_spaces[i].spnum,
			pa_def_spaces[i].loadable, pa_def_spaces[i].defined,
			pa_def_spaces[i].private, pa_def_spaces[i].sort, 0,
			pa_def_spaces[i].segment);
      i++;
    }

  i = 0;
  while (pa_def_subspaces[i].name)
    {
      space = pa_segment_to_space (pa_def_spaces[pa_def_subspaces[i].def_space_index].segment);
      if (space)
	{
	  char *name = pa_def_subspaces[i].alias;
	  if (!name)
	    name = pa_def_subspaces[i].name;
	  create_new_subspace (space, name,
			       pa_def_subspaces[i].defined,
			       pa_def_subspaces[i].loadable,
		  pa_def_subspaces[i].code_only, pa_def_subspaces[i].common,
		   pa_def_subspaces[i].dup_common, pa_def_subspaces[i].zero,
		       pa_def_subspaces[i].sort, pa_def_subspaces[i].access,
			       pa_def_subspaces[i].space_index,
			       pa_def_subspaces[i].alignment,
			       pa_def_subspaces[i].quadrant,
		pa_def_spaces[pa_def_subspaces[i].def_space_index].segment);
	  subseg_new (name, pa_def_subspaces[i].subsegment);
	}
      else
	as_fatal ("Internal error: space missing for subspace \"%s\"\n",
		  pa_def_subspaces[i].name);
      i++;
    }
}

space_dict_chainS *
create_new_space (name, spnum, loadable, defined, private, sort, defined_in_file, seg)
     char *name;
     int spnum;
     char loadable;
     char defined;
     char private;
     char sort;
     char defined_in_file;
     asection *seg;

{
  Elf_Internal_Shdr *new_space;
  space_dict_chainS *chain_entry;

  new_space = (Elf_Internal_Shdr *) xmalloc (sizeof (Elf_Internal_Shdr));
  if (!new_space)
    as_fatal ("Out of memory: could not allocate new Elf_Internal_Shdr: %s\n", name);

  /*
  new_space->space_number = spnum;
  new_space->is_loadable = loadable & 1;
  new_space->is_defined = defined & 1;
  new_space->is_private = private & 1;
  new_space->sort_key = sort & 0xff;

  new_space->loader_fix_index = ~0;
  new_space->loader_fix_quantity = 0;
  new_space->init_pointer_index = ~0;
  new_space->init_pointer_quantity = 0;
  new_space->subspace_quantity = 0;
  */

  chain_entry = (space_dict_chainS *) xmalloc (sizeof (space_dict_chainS));
  if (!chain_entry)
    as_fatal ("Out of memory: could not allocate new space chain entry: %s\n", name);

  SPACE_NAME (chain_entry) = (char *) xmalloc (strlen (name) + 1);
  strcpy (SPACE_NAME (chain_entry), name);

  chain_entry->sd_entry = new_space;
  chain_entry->sd_defined = defined_in_file;
  chain_entry->sd_seg = seg;
  chain_entry->sd_last_subseg = -1;
  chain_entry->sd_next = NULL;

  SPACE_SPNUM (chain_entry) = spnum;
  SPACE_LOADABLE (chain_entry) = loadable & 1;
  SPACE_DEFINED (chain_entry) = defined & 1;
  SPACE_PRIVATE (chain_entry) = private & 1;
  SPACE_SORT (chain_entry) = sort & 0xff;

  /* find spot for the new space based on its sort key */

  if (!space_dict_last)
    space_dict_last = chain_entry;

  if (space_dict_root == NULL)	/* if root is null, it is very easy */
    space_dict_root = chain_entry;
  else
    {
      space_dict_chainS *sdcP;
      space_dict_chainS *last_sdcP;

      sdcP = space_dict_root;
      last_sdcP = NULL;

      while (sdcP)
	{
	  if (SPACE_SORT (sdcP) < SPACE_SORT (chain_entry))
	    {
	      last_sdcP = sdcP;
	      sdcP = sdcP->sd_next;
	    }
	  else if (SPACE_SORT (sdcP) == SPACE_SORT (chain_entry))
	    {
	      last_sdcP = sdcP;
	      sdcP = sdcP->sd_next;
	    }
	  else if (SPACE_SORT (sdcP) > SPACE_SORT (chain_entry))
	    {
	      break;
	    }
	}

      if (last_sdcP)
	{
	  chain_entry->sd_next = sdcP;
	  last_sdcP->sd_next = chain_entry;
	}
      else
	{
	  space_dict_root = chain_entry;
	  chain_entry->sd_next = sdcP;
	}

      if (chain_entry->sd_next == NULL)
	space_dict_last = chain_entry;
    }

  return chain_entry;
}

subspace_dict_chainS
* create_new_subspace (space, name, defined, loadable, code_only, common, dup_common,
	       is_zero, sort, access, space_index, alignment, quadrant, seg)
     space_dict_chainS *space;
     char *name;
     char defined, loadable, code_only, common, dup_common, is_zero;
     char sort;
     int access;
     int space_index;
     int alignment;
     int quadrant;
     asection *seg;
{
  Elf_Internal_Shdr *new_subspace;
  subspace_dict_chainS *chain_entry;
  symbolS *start_symbol;

  new_subspace = (Elf_Internal_Shdr *) xmalloc (sizeof (Elf_Internal_Shdr));
  if (!new_subspace)
    as_fatal ("Out of memory: could not allocate new Elf_Internal_Shdr: %s\n",
	      name);

  /*
  new_subspace->space_index = space_index;
  new_subspace->fixup_request_index = ~0;
  */

  chain_entry = (subspace_dict_chainS *) xmalloc (sizeof (subspace_dict_chainS));
  if (!chain_entry)
    as_fatal ("Out of memory: could not allocate new subspace chain entry: %s\n", name);

  chain_entry->ssd_entry = new_subspace;
  SUBSPACE_NAME (chain_entry) = (char *) xmalloc (strlen (name) + 1);
  strcpy (SUBSPACE_NAME (chain_entry), name);

  SUBSPACE_ACCESS (chain_entry) = access & 0x7f;
  SUBSPACE_LOADABLE (chain_entry) = loadable & 1;
  SUBSPACE_COMMON (chain_entry) = common & 1;
  SUBSPACE_DUP_COMM (chain_entry) = dup_common & 1;
  SUBSPACE_SORT (chain_entry) = sort & 0xff;
  SET_SUBSPACE_CODE_ONLY (chain_entry, code_only & 1);
  SUBSPACE_ALIGN (chain_entry) = alignment & 0xffff;
  SUBSPACE_QUADRANT (chain_entry) = quadrant & 0x3;
  SUBSPACE_SUBSPACE_START (chain_entry) = pa_subspace_start (space, quadrant);

  chain_entry->ssd_defined = defined;
  chain_entry->ssd_space_number = space_index;
  chain_entry->ssd_subseg = pa_next_subseg (space);
  chain_entry->ssd_seg = seg;
  SUBSPACE_ZERO (chain_entry) = is_zero;
  chain_entry->ssd_last_align = 1;
  chain_entry->ssd_next = NULL;

  /* find spot for the new subspace based on its sort key */

  if (space->sd_subspaces == NULL)	/* if root is null, it is very easy */
    space->sd_subspaces = chain_entry;
  else
    {
      subspace_dict_chainS *ssdcP;
      subspace_dict_chainS *last_ssdcP;

      ssdcP = space->sd_subspaces;
      last_ssdcP = NULL;

      while (ssdcP)
	{
	  if (SUBSPACE_SORT (ssdcP) < SUBSPACE_SORT (chain_entry))
	    {
	      last_ssdcP = ssdcP;
	      ssdcP = ssdcP->ssd_next;
	    }
	  else if (SUBSPACE_SORT (ssdcP) == SUBSPACE_SORT (chain_entry))
	    {
	      last_ssdcP = ssdcP;
	      ssdcP = ssdcP->ssd_next;
	    }
	  else if (SUBSPACE_SORT (ssdcP) > SUBSPACE_SORT (chain_entry))
	    {
	      break;
	    }
	}

      if (last_ssdcP)
	{
	  chain_entry->ssd_next = ssdcP;
	  last_ssdcP->ssd_next = chain_entry;
	}
      else
	{
	  space->sd_subspaces = chain_entry;
	  chain_entry->ssd_next = ssdcP;
	}
    }

  start_symbol = pa_set_start_symbol (seg, space->sd_last_subseg);
  chain_entry->ssd_start_sym = start_symbol;
  return chain_entry;

}

subspace_dict_chainS
* update_subspace (name, defined, loadable, code_only, common, dup_common, sort, zero,
		   access, space_index, alignment, quadrant, subseg)
     char *name;
     char defined, loadable, code_only, common, dup_common, zero;
     char sort;
     int access;
     int space_index;
     int alignment;
     int quadrant;
     subsegT subseg;
{
  subspace_dict_chainS *chain_entry;
  subspace_dict_chainS *is_defined_subspace ();

  if ((chain_entry = is_defined_subspace (name, subseg)))
    {

      SUBSPACE_ACCESS (chain_entry) = access & 0x7f;
      SUBSPACE_LOADABLE (chain_entry) = loadable & 1;
      SUBSPACE_COMMON (chain_entry) = common & 1;
      SUBSPACE_DUP_COMM (chain_entry) = dup_common & 1;
      SET_SUBSPACE_CODE_ONLY (chain_entry, code_only & 1);
      SUBSPACE_SORT (chain_entry) = sort & 0xff;
      /* chain_entry->ssd_entry->space_index = space_index; */
      SUBSPACE_ALIGN (chain_entry) = alignment & 0xffff;
      SUBSPACE_QUADRANT (chain_entry) = quadrant & 0x3;

      chain_entry->ssd_defined = defined;
      chain_entry->ssd_space_number = space_index;
      SUBSPACE_ZERO (chain_entry) = zero;
    }
  else
    chain_entry = NULL;

  return chain_entry;

}

space_dict_chainS *
is_defined_space (name)
     char *name;
{
  space_dict_chainS *spaceCh;

  for (spaceCh = space_dict_root; spaceCh; spaceCh = spaceCh->sd_next)
    {
      if (strcmp (SPACE_NAME (spaceCh), name) == 0)
	{
	  return spaceCh;
	}
    }

  return NULL;
}

space_dict_chainS *
pa_segment_to_space (seg)
     asection *seg;
{
  space_dict_chainS *spaceCh;

  for (spaceCh = space_dict_root; spaceCh; spaceCh = spaceCh->sd_next)
    {
      if (spaceCh->sd_seg == seg)
	{
	  return spaceCh;
	}
    }

  return NULL;
}

subspace_dict_chainS *
is_defined_subspace (name, subseg)
     char *name;
     subsegT subseg;
{
  space_dict_chainS *spaceCh;
  subspace_dict_chainS *subspCh;

  for (spaceCh = space_dict_root; spaceCh; spaceCh = spaceCh->sd_next)
    {
      for (subspCh = spaceCh->sd_subspaces; subspCh; subspCh = subspCh->ssd_next)
	{
	  /*
	if ( strcmp(SUBSPACE_NAME(subspCh),name) == 0 &&
	    subspCh->ssd_subseg == subseg ) {
       */
	  if (strcmp (SUBSPACE_NAME (subspCh), name) == 0)
	    {
	      return subspCh;
	    }
	}
    }
  return NULL;
}

subspace_dict_chainS *
pa_subsegment_to_subspace (seg, subseg)
     asection *seg;
     subsegT subseg;
{
  space_dict_chainS *spaceCh;
  subspace_dict_chainS *subspCh;

  for (spaceCh = space_dict_root; spaceCh; spaceCh = spaceCh->sd_next)
    {
      if (spaceCh->sd_seg == seg)
	{
	  for (subspCh = spaceCh->sd_subspaces; subspCh; subspCh = subspCh->ssd_next)
	    {
	      if (subspCh->ssd_subseg == (int) subseg)
		{
		  return subspCh;
		}
	    }
	}
    }

  return NULL;
}

space_dict_chainS *
pa_find_space_by_number (number)
     int number;
{
  space_dict_chainS *spaceCh;

  for (spaceCh = space_dict_root; spaceCh; spaceCh = spaceCh->sd_next)
    {
      if (SPACE_SPNUM (spaceCh) == number)
	{
	  return spaceCh;
	}
    }

  return NULL;
}

unsigned int 
pa_subspace_start (space, quadrant)
     space_dict_chainS *space;
     int quadrant;
{
  if ((strcasecmp (SPACE_NAME (space), "$PRIVATE$") == 0) &&
      quadrant == 1)
    {
      return 0x40000000;
    }
  else if (space->sd_seg == data_section && quadrant == 1)
    {				/* in case name is */
      /* already converted */
      /* to a space dict- */
      /* ionary index */
      return 0x40000000;
    }
  else
    return 0;
}

int 
pa_next_subseg (space)
     space_dict_chainS *space;
{

  space->sd_last_subseg++;
  return space->sd_last_subseg;
}

int 
is_last_defined_subspace (ssd)
     subspace_dict_chainS *ssd;
{

  for (; ssd; ssd = ssd->ssd_next)
    {
      if (ssd->ssd_defined)
	return FALSE;
    }

  return TRUE;
}

symbolS *
pa_get_start_symbol (seg, subseg)
     asection *seg;
     subsegT subseg;
{
  symbolS *start_symbol;
  subspace_dict_chainS *ssd;

  start_symbol = NULL;

  /* each time a new space is created, build a symbol called LS$START_seg_subseg$ */
  /* where <space-name> is the name of the space */
  /* the start symbol will be SS_LOCAL and ST_CODE */

  if (seg == bfd_make_section_old_way (stdoutput, ".text") ||
      seg == bfd_make_section_old_way (stdoutput, ".data") ||
      seg == bfd_make_section_old_way (stdoutput, GDB_DEBUG_SPACE_NAME))
    {
      ssd = pa_subsegment_to_subspace (seg, subseg);
      if (ssd)
	{
	  start_symbol = ssd->ssd_start_sym;
	}
      else
	as_fatal ("Internal error: missing subspace for (seg,subseg)=('%s',%d)",
		  seg->name, subseg);
    }
  else
    as_fatal ("Internal error: attempt to find start symbol for unloadable segment: '%s'",
	      seg->name);

  return start_symbol;
}

/*
  Function to define a symbol whose address is the beginning of a subspace.
  This function assumes the symbol is to be defined for the current subspace.
 */

symbolS *
pa_set_start_symbol (seg, subseg)
     asection *seg;
     subsegT subseg;
{
  symbolS *start_symbol;
  subspace_dict_chainS *ssd;
  char *symbol_name;

  symbol_name = (char *) xmalloc (strlen ("LS$START__000000$") + strlen (seg->name) + 1);

  sprintf (symbol_name, "LS$START_%s_%03d$", seg->name, subseg);

  start_symbol
    = symbol_new (symbol_name, seg, 0, frag_now);	/* XXX: not sure if value s.b. 0 or frag s.b. NULL */

  start_symbol->bsym->flags = BSF_LOCAL;	/* XXX: isn't there a macro defined for this? */

  /* each time a new space is created, build a symbol called LS$START_seg_subseg$ */
  /* where <space-name> is the name of the space */
  /* the start symbol will be SS_LOCAL and ST_CODE */
  /* This function assumes that (seg,subseg) is a new subsegment(subspace) */

  if (seg == bfd_make_section_old_way (stdoutput, ".text") ||
      seg == bfd_make_section_old_way (stdoutput, ".data") ||
      seg == bfd_make_section_old_way (stdoutput, GDB_DEBUG_SPACE_NAME))
    {
      ssd = pa_subsegment_to_subspace (seg, subseg);
      if (ssd)
	{
	  ssd->ssd_start_sym = start_symbol;
	}
      else
	as_fatal ("Internal error: missing subspace for (seg,subseg)=('%s',%d)",
		  seg, subseg);
    }
  else
    as_fatal ("Internal error: attempt to define start symbol for unloadable segment: '%s'",
	      seg->name);

  return start_symbol;
}

static unsigned int
pa_stringer_aux (s)
     char *s;
{
  unsigned int c = *s & CHAR_MASK;
  switch (c)
    {
    case '\"':
      c = NOT_A_CHAR;
      break;
    default:
      break;
    }
  return c;
}

void
pa_stringer (append_zero)	/* Worker to do .ascii etc statements. */
     /* Checks end-of-line. */
     register int append_zero;	/* 0: don't append '\0', else 1 */
{
  char *s;
  unsigned int c;
  char num_buf[4];
  int i;

  /* Preprocess the string to handle PA-specific escape sequences.	*/
  /* For example, \xDD where DD is a hexidecimal number should be	*/
  /* changed to \OOO where OOO is an octal number.			*/

  s = input_line_pointer + 1;	/* skip the opening quote */

  while (is_a_char (c = pa_stringer_aux (s++)))
    {
      if (c == '\\')
	{
	  c = *s;
	  switch (c)
	    {
	    case 'x':
	      {
		unsigned int number;
		int num_digit;
		char dg;
		char *s_start = s;

		s++;		/* get past the 'x' */
		for (num_digit = 0, number = 0, dg = *s;
		     num_digit < 2
		     && (isdigit (dg) || (dg >= 'a' && dg <= 'f')
			 || (dg >= 'A' && dg <= 'F'));
		     num_digit++)
		  {
		    if (isdigit (dg))
		      number = number * 16 + dg - '0';
		    else if (dg >= 'a' && dg <= 'f')
		      number = number * 16 + dg - 'a' + 10;
		    else
		      number = number * 16 + dg - 'A' + 10;

		    s++;
		    dg = *s;
		  }
		if (num_digit > 0)
		  {
		    switch (num_digit)
		      {
		      case 1:
			sprintf (num_buf, "%02o", number);
			break;
		      case 2:
			sprintf (num_buf, "%03o", number);
			break;
		      }
		    for (i = 0; i <= num_digit; i++)
		      s_start[i] = num_buf[i];
		  }
		break;
	      }
	      /* This might be a "\"", skip over the escaped char.  */
	    default:
	      s++;
	      break;
	    }
	}
    }
  stringer (append_zero);
  pa_undefine_label ();
}

void
pa_version ()
{
#ifdef OBJ_ELF
  obj_elf_version ();
#endif
  pa_undefine_label ();
}

void
pa_cons (nbytes)
     register unsigned int nbytes;	/* 1=.byte, 2=.word, 4=.long */
{
  cons (nbytes);
  pa_undefine_label ();
}

void
pa_data ()
{
  s_data (0);
  pa_undefine_label ();
}

void
pa_desc ()
{

#ifdef OBJ_ELF
  obj_elf_desc ();
#endif
  pa_undefine_label ();
}

void
pa_float_cons (float_type)
     register int float_type;	/* 'f':.ffloat ... 'F':.float ... */
{
  float_cons (float_type);
  pa_undefine_label ();
}

void
pa_fill ()
{
  s_fill (0);
  pa_undefine_label ();
}

void
pa_lcomm (needs_align)
     /* 1 if this was a ".bss" directive, which may require a 3rd argument
	(alignment); 0 if it was an ".lcomm" (2 args only)  */
     int needs_align;
{
  s_lcomm (needs_align);
  pa_undefine_label ();
}

void
pa_lsym ()
{
  s_lsym (0);
  pa_undefine_label ();
}

void
pa_text ()
{
  s_text (0);
  pa_undefine_label ();
}

static symext_chainS *symext_rootP = NULL;
static symext_chainS *symext_lastP = NULL;

void
hppa_tc_symbol (abfd, symbolP, sym_idx)
     bfd * abfd;
     elf_symbol_type * symbolP;
     int sym_idx;
{
  symext_chainS *symextP;
  unsigned int arg_reloc;

  if (!(symbolP->symbol.flags & BSF_FUNCTION))
    return;

  arg_reloc = symbolP->tc_data.hppa_arg_reloc;

  symextP = (symext_chainS *) bfd_alloc (abfd, sizeof (symext_chainS) * 2);

  symextP[0].entry = ELF32_HPPA_SX_WORD (HPPA_SXT_SYMNDX, sym_idx);
  symextP[0].next = &symextP[1];

  symextP[1].entry = ELF32_HPPA_SX_WORD (HPPA_SXT_ARG_RELOC, arg_reloc);
  symextP[1].next = NULL;

  if (symext_rootP == NULL)
    {
      symext_rootP = &symextP[0];
      symext_lastP = &symextP[1];
    }
  else
    {
      symext_lastP->next = &symextP[0];
      symext_lastP = &symextP[1];
    }
}

void
hppa_tc_make_sections (abfd)
bfd * abfd;
{
  symext_chainS *symextP;
  symext_entryS *outbound_symexts;
  int size;
  int n;
  extern void hppa_elf_stub_finish ();	/* forward declaration */
  asection *symextn_sec;
  segT save_seg = now_seg;
  subsegT save_subseg = now_subseg;

  hppa_tc_make_symextn_section();

  bfd_set_section_contents(stdoutput, stdoutput->sections, "", 0, 0);	/* force some calculations */

  hppa_elf_stub_finish (abfd);

  if (symext_rootP == NULL)
    return;

  for (n = 0, symextP = symext_rootP; symextP; symextP = symextP->next, ++n)
    ;

  size = sizeof (symext_entryS) * n;

  symextn_sec = subseg_new(SYMEXTN_SECTION_NAME, 0);

  frag_wane (frag_now);
  frag_new (0);

  for (symextP = symext_rootP; symextP; symextP = symextP->next)
    {
      char *ptr;
      extern int *elf_get_symtab_map();
      Elf_Sym_Extra *symextra = elf_sym_extra (abfd);
      int idx;

      /* First, patch the symbol extension record to reflect the true */
      /* symbol table index */

      if (ELF32_HPPA_SX_TYPE(symextP->entry) == HPPA_SXT_SYMNDX)
	{
	  idx = ELF32_HPPA_SX_VAL(symextP->entry) - 1;
	  symextP->entry = ELF32_HPPA_SX_WORD (HPPA_SXT_SYMNDX,
					       symextra[idx].elf_sym_num);
	}

      ptr = frag_more(sizeof(symextP->entry));
      md_number_to_chars(ptr,symextP->entry,sizeof(symextP->entry));
    }

  frag_now->fr_fix = obstack_next_free (&frags) - frag_now->fr_literal;
  frag_wane (frag_now);

  /* now, switch back to the original segment */

  subseg_set(save_seg, save_subseg);

  return;
}

static void
hppa_tc_make_symextn_section()
{
  extern symext_chainS *elf32_hppa_get_symextn_chain();

  if (symext_rootP)
    {
      symext_chainS *symextP;
      int n;
      int size;
      segT symextn_sec;
      segT save_seg = now_seg;
      subsegT save_subseg = now_subseg;

      for (n = 0, symextP = symext_rootP; symextP; symextP = symextP->next, ++n)
	;

      size = sizeof (symext_entryS) * n;

      symextn_sec = subseg_new(SYMEXTN_SECTION_NAME, 0);

      bfd_set_section_flags(stdoutput, symextn_sec, SEC_LOAD | SEC_HAS_CONTENTS | SEC_DATA);
      bfd_set_section_size (stdoutput, symextn_sec, size);

      /* now, switch back to the original segment */
      subseg_set(save_seg, save_subseg);
    }
}