/* tc-h8300.c -- Assemble code for the Hitachi H8/300
Copyright (C) 1991, 1992 Free Software Foundation.
-
+
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 2, 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. */
-/*
+/*
Written By Steve Chamberlain
sac@cygnus.com
*/
#include <stdio.h>
#include "as.h"
#include "bfd.h"
+#define DEFINE_TABLE
+#define h8_opcodes ops
#include "opcode/h8300.h"
#include <ctype.h>
-#include "listing.h"
-char comment_chars[] = { ';',0 };
-char line_separator_chars[] = { '$' ,0};
+const char comment_chars[] =
+{';', 0};
+const char line_separator_chars[] =
+{'$', 0};
+const char line_comment_chars[] = "#";
/* This table describes all the machine specific pseudo-ops the assembler
has to support. The fields are:
Integer arg to pass to the function
*/
-void cons();
+void cons ();
+
+int Hmode;
+#define PSIZE (Hmode ? L_32 : L_16)
+#define DMODE (L_16)
+#define DSYMMODE (Hmode ? L_24 : L_16)
+int bsize = L_8; /* default branch displacement */
+
+
+void
+h8300hmode ()
+{
+ Hmode = 1;
+}
+
+
+void
+sbranch (size)
+ int size;
+{
+ bsize = size;
+}
-const pseudo_typeS md_pseudo_table[] =
+const pseudo_typeS md_pseudo_table[] =
{
-{ "int", cons, 2 },
-{ "data.b", cons, 1 },
-{ "data.w", cons, 2 },
-{ "data.l", cons, 4 },
-{ "form", listing_psize, 0 },
-{ "heading", listing_title, 0},
-{ "import", s_ignore, 0},
-{ "page", listing_eject, 0},
-{ "program", s_ignore, 0},
-{ 0,0,0 }
+
+ {"h8300h", h8300hmode, 0},
+ {"sbranch", sbranch, L_8},
+ {"lbranch", sbranch, L_16},
+
+ {"int", cons, 2},
+ {"data.b", cons, 1},
+ {"data.w", cons, 2},
+ {"data.l", cons, 4},
+ {"form", listing_psize, 0},
+ {"heading", listing_title, 0},
+ {"import", s_ignore, 0},
+ {"page", listing_eject, 0},
+ {"program", s_ignore, 0},
+ {0, 0, 0}
};
-int md_reloc_size ;
+const int md_reloc_size;
const char EXP_CHARS[] = "eE";
/* Chars that mean this number is a floating point constant */
/* As in 0f12.456 */
/* or 0d1.2345e12 */
-char FLT_CHARS[] = "rRsSfFdDxXpP";
+const char FLT_CHARS[] = "rRsSfFdDxXpP";
const relax_typeS md_relax_table[1];
static struct hash_control *opcode_hash_control; /* Opcode mnemonics */
-
/*
This function is called once, at assembler startup time. This should
set up all the tables, etc that the MD part of the assembler needs
*/
-#if 0
-/* encode the size and number into the number field
- xxnnnn
- 00 8 bit
- 01 16 bit
- 10 ccr
- nnnnreg number
- */
-#define WORD_REG 0x10
-#define BYTE_REG 0x00
-#define CCR_REG 0x20
-struct reg_entry
-{
- char *name;
- char number;
-};
-
-struct reg_entry reg_list[] = {
- "r0",WORD_REG +0,
- "r1",WORD_REG +1,
- "r2",WORD_REG +2,
- "r3",WORD_REG +3,
- "r4",WORD_REG +4,
- "r5",WORD_REG +5,
- "r6",WORD_REG +6,
- "r7",WORD_REG +7,
- "fp",WORD_REG +6,
- "sp",WORD_REG +7,
- "r0h",BYTE_REG + 0,
- "r0l",BYTE_REG + 1,
- "r1h",BYTE_REG + 2,
- "r1l",BYTE_REG + 3,
- "r2h",BYTE_REG + 4,
- "r2l",BYTE_REG + 5,
- "r3h",BYTE_REG + 6,
- "r3l",BYTE_REG + 7,
- "r4h",BYTE_REG + 8,
- "r4l",BYTE_REG + 9,
- "r5h",BYTE_REG + 10,
- "r5l",BYTE_REG + 11,
- "r6h",BYTE_REG + 12,
- "r6l",BYTE_REG + 13,
- "r7h",BYTE_REG + 14,
- "r7l",BYTE_REG + 15,
- "ccr",CCR_REG,
- 0,0
- }
-;
-#endif
+void
+md_begin ()
+{
+ struct h8_opcode *opcode;
+ const struct reg_entry *reg;
+ char prev_buffer[100];
+ int idx = 0;
+ opcode_hash_control = hash_new ();
+ prev_buffer[0] = 0;
-void md_begin ()
-{
- struct h8_opcode *opcode;
- const struct reg_entry *reg;
- char prev_buffer[100];
- int idx = 0;
-
- opcode_hash_control = hash_new();
- prev_buffer[0] = 0;
-
- for (opcode = h8_opcodes; opcode->name; opcode++)
+ for (opcode = h8_opcodes; opcode->name; opcode++)
+ {
+ /* Strip off any . part when inserting the opcode and only enter
+ unique codes into the hash table
+ */
+ char *src = opcode->name;
+ unsigned int len = strlen (src);
+ char *dst = malloc (len + 1);
+ char *buffer = dst;
+
+ opcode->size = 0;
+ while (*src)
+ {
+ if (*src == '.')
{
- /* Strip off any . part when inserting the opcode and only enter
- unique codes into the hash table
- */
- char *src= opcode->name;
- unsigned int len = strlen(src);
- char *dst = malloc(len+1);
- char *buffer = dst;
- opcode->size = 0;
- while (*src) {
- if (*src == '.') {
- *dst++ = 0;
- src++;
- opcode->size = *src;
- break;
- }
- *dst++ = *src++;
- }
- if (strcmp(buffer, prev_buffer))
- {
- hash_insert(opcode_hash_control, buffer, (char *)opcode);
- strcpy(prev_buffer, buffer);
- idx++;
- }
- opcode->idx = idx;
-
-
- /* Find the number of operands */
- opcode->noperands = 0;
- while (opcode->args.nib[opcode->noperands] != E)
- opcode->noperands ++;
- /* Find the length of the opcode in bytes */
- opcode->length =0;
- while (opcode->data.nib[opcode->length*2] != E)
- opcode->length++;
+ src++;
+ opcode->size = *src;
+ break;
}
-
+ *dst++ = *src++;
+ }
+ *dst++ = 0;
+ if (strcmp (buffer, prev_buffer))
+ {
+ hash_insert (opcode_hash_control, buffer, (char *) opcode);
+ strcpy (prev_buffer, buffer);
+ idx++;
+ }
+ opcode->idx = idx;
+
+
+ /* Find the number of operands */
+ opcode->noperands = 0;
+ while (opcode->args.nib[opcode->noperands] != E)
+ opcode->noperands++;
+ /* Find the length of the opcode in bytes */
+ opcode->length = 0;
+ while (opcode->data.nib[opcode->length * 2] != E)
+ opcode->length++;
+ }
+
}
-struct h8_exp {
- char *e_beg;
- char *e_end;
- expressionS e_exp;
-};
-struct h8_op
+struct h8_exp
{
- unsigned int dispreg;
- op_type mode;
- unsigned reg;
- expressionS exp;
+ char *e_beg;
+ char *e_end;
+ expressionS e_exp;
};
+int dispreg;
+int opsize; /* Set when a register size is seen */
+struct h8_op
+{
+ op_type mode;
+ unsigned reg;
+ expressionS exp;
+};
/*
- parse operands
+ parse operands
WREG r0,r1,r2,r3,r4,r5,r6,r7,fp,sp
r0l,r0h,..r7l,r7h
@WREG
@WREG+
@-WREG
#const
-
- */
-op_type r8_sord[] = {RS8, RD8};
-op_type r16_sord[] = {RS16, RD16};
-op_type rind_sord[] = {RSIND, RDIND};
-op_type abs_sord[2] = {ABS16SRC, ABS16DST};
-op_type disp_sord[] = {DISPSRC, DISPDST};
+ */
/* try and parse a reg name, returns number of chars consumed */
-int
- DEFUN(parse_reg,(src, mode, reg, dst),
- char *src AND
- op_type *mode AND
- unsigned int *reg AND
- int dst)
+int
+parse_reg (src, mode, reg, direction)
+ char *src;
+ op_type *mode;
+ unsigned int *reg;
+ int direction;
+
{
- if (src[0] == 's' && src[1] == 'p')
- {
- *mode = r16_sord[dst];
- *reg = 7;
- return 2;
- }
- if (src[0] == 'c' && src[1] == 'c' && src[2] == 'r')
- {
- *mode = CCR;
- *reg = 0;
- return 3;
- }
- if (src[0] == 'f' && src[1] == 'p')
+ if (src[0] == 's' && src[1] == 'p')
+ {
+ *mode = PSIZE | REG | direction;
+ *reg = 7;
+ return 2;
+ }
+ if (src[0] == 'c' && src[1] == 'c' && src[2] == 'r')
+ {
+ *mode = CCR;
+ *reg = 0;
+ return 3;
+ }
+ if (src[0] == 'f' && src[1] == 'p')
+ {
+ *mode = PSIZE | REG | direction;
+ *reg = 6;
+ return 2;
+ }
+ if (src[0] == 'e'
+ && src[1] == 'r'
+ && src[2] >= '0' && src[2] <= '7')
+ {
+ *mode = L_32 | REG | direction;
+ *reg = src[2] - '0';
+ if (!Hmode)
+ as_warn ("Reg only legal for H8/300-H");
+
+ return 3;
+ }
+ if (src[0] == 'e'
+ && src[1] >= '0' && src[1] <= '7')
+ {
+ *mode = L_16 | REG | direction;
+ *reg = src[1] - '0' + 8;
+ if (!Hmode)
+ as_warn ("Reg only legal for H8/300-H");
+ return 2;
+ }
+
+ if (src[0] == 'r')
+ {
+ if (src[1] >= '0' && src[1] <= '7')
+ {
+ if (src[2] == 'l')
{
- *mode = r16_sord[dst];
- *reg = 6;
- return 2;
+ *mode = L_8 | REG | direction;
+ *reg = (src[1] - '0') + 8;
+ return 3;
}
- if (src[0] == 'r')
+ if (src[2] == 'h')
{
- if (src[1] >= '0' && src[1] <= '7')
- {
- if(src[2] == 'l')
- {
- *mode = r8_sord[dst];
- *reg = (src[1] - '0') + 8;
- return 3;
- }
- if(src[2] == 'h')
- {
- *mode = r8_sord[dst];
- *reg = (src[1] - '0') ;
- return 3;
- }
- *mode = r16_sord[dst];
- *reg = (src[1] - '0');
- return 2;
- }
+ *mode = L_8 | REG | direction;
+ *reg = (src[1] - '0');
+ return 3;
}
- return 0;
+ *mode = L_16 | REG | direction;
+ *reg = (src[1] - '0');
+ return 2;
+ }
+ }
+ return 0;
}
char *
- DEFUN(parse_exp,(s, op),
- char *s AND
- expressionS *op)
+DEFUN (parse_exp, (s, op),
+ char *s AND
+ expressionS * op)
{
- char *save = input_line_pointer;
- char *new;
- segT seg;
- input_line_pointer = s;
- seg = expr(0,op);
- new = input_line_pointer;
- input_line_pointer = save;
- if (SEG_NORMAL(seg))
- return new;
- switch (seg) {
- case SEG_ABSOLUTE:
- case SEG_UNKNOWN:
- case SEG_DIFFERENCE:
- case SEG_BIG:
- case SEG_REGISTER:
- return new;
- case SEG_ABSENT:
- as_bad("Missing operand");
- return new;
- default:
- as_bad("Don't understand operand of type %s", segment_name (seg));
- return new;
- }
+ char *save = input_line_pointer;
+ char *new;
+ segT seg;
+
+ input_line_pointer = s;
+ seg = expr (0, op);
+ new = input_line_pointer;
+ input_line_pointer = save;
+ if (SEG_NORMAL (seg))
+ return new;
+ switch (seg)
+ {
+ case SEG_ABSOLUTE:
+ case SEG_UNKNOWN:
+ case SEG_DIFFERENCE:
+ case SEG_BIG:
+ case SEG_REGISTER:
+ return new;
+ case SEG_ABSENT:
+ as_bad ("Missing operand");
+ return new;
+ default:
+ as_bad ("Don't understand operand of type %s", segment_name (seg));
+ return new;
+ }
}
static char *
- DEFUN(skip_colonthing,(ptr),
- char *ptr)
+skip_colonthing (ptr, exp, mode)
+ char *ptr;
+ expressionS *exp;
+ int *mode;
{
- if (*ptr == ':') {
- ptr++;
- while (isdigit(*ptr))
- ptr++;
-
+ if (*ptr == ':')
+ {
+ ptr++;
+ if (*ptr == '8')
+ {
+ ptr++;
+ /* ff fill any 8 bit quantity */
+ exp->X_add_number |= 0xff00;
}
- return ptr;
+ else
+ {
+ *mode &= ~SIZE;
+ if (*ptr == '2')
+ {
+ *mode |= L_24;
+ }
+ else if (*ptr == '1')
+ {
+ *mode |= L_16;
+ }
+ while (isdigit (*ptr))
+ ptr++;
+ }
+ }
+ return ptr;
}
/* The many forms of operand:
-
+
Rn Register direct
@Rn Register indirect
@(exp[:16], Rn) Register indirect with displacement
@aa:8 absolute 8 bit
@aa:16 absolute 16 bit
@aa absolute 16 bit
-
+
#xx[:size] immediate data
@(exp:[8], pc) pc rel
@@aa[:8] memory indirect
-
+
*/
-static void
- DEFUN(get_operand,(ptr, op, dst),
- char **ptr AND
- struct h8_op *op AND
- unsigned int dst)
+char *
+colonmod24 (op, src)
+ struct h8_op *op;
+ char *src;
+
+{
+ int mode = 0;
+ src = skip_colonthing (src, &op->exp, &mode);
+
+ if (!mode)
+ {
+ /* Choose a default mode */
+ if (op->exp.X_add_number < -32768
+ || op->exp.X_add_number > 32767)
+ {
+ if (Hmode)
+ mode = L_24;
+ else
+ mode = L_16;
+ }
+ else if (op->exp.X_add_symbol
+ || op->exp.X_subtract_symbol)
+ mode = DSYMMODE;
+ else
+ mode = DMODE;
+ }
+ op->mode |= mode;
+ return src;
+
+}
+
+
+static void
+get_operand (ptr, op, dst, direction)
+ char **ptr;
+ struct h8_op *op;
+ unsigned int dst;
+
{
char *src = *ptr;
op_type mode;
- unsigned int num;
- unsigned int len;
+ unsigned int num;
+ unsigned int len;
unsigned int size;
+
op->mode = E;
-
- len = parse_reg(src, &op->mode, &op->reg, dst);
- if (len) {
- *ptr = src + len;
- return ;
- }
-
- if (*src == '@')
- {
- src++;
- if (*src == '@')
+
+ len = parse_reg (src, &op->mode, &op->reg, direction);
+ if (len)
{
- src++;
- src = parse_exp(src,&op->exp);
- src = skip_colonthing(src);
-
- *ptr = src;
-
- op->mode = MEMIND;
- return;
-
- }
-
-
- if (*src == '-')
- {
- src++;
- len = parse_reg(src, &mode, &num, dst);
- if (len == 0)
- {
- /* Oops, not a reg after all, must be ordinary exp */
- src--;
- /* must be a symbol */
- op->mode = abs_sord[dst];
- *ptr = skip_colonthing(parse_exp(src, &op->exp));
-
- return;
-
-
- }
-
- if (mode != r16_sord[dst])
- {
- as_bad("@- needs word register");
- }
- op->mode = RDDEC;
- op->reg = num;
*ptr = src + len;
return;
}
- if (*src == '(' && ')')
+
+ if (*src == '@')
{
- /* Disp */
- src++;
- src = parse_exp(src, &op->exp);
-
- if (*src == ')')
- {
- src++;
- op->mode = abs_sord[dst];
- *ptr = src;
- return;
- }
- src = skip_colonthing(src);
-
- if (*src != ',')
- {
- as_bad("expected @(exp, reg16)");
- return;
-
- }
src++;
- len = parse_reg(src, &mode, &op->reg, dst);
- if (len == 0 || mode != r16_sord[dst])
- {
- as_bad("expected @(exp, reg16)");
- return;
- }
- op->mode = disp_sord[dst];
- src += len;
- src = skip_colonthing(src);
-
- if (*src != ')' && '(')
- {
- as_bad("expected @(exp, reg16)");
- return;
- }
- *ptr = src +1;
-
- return;
- }
- len = parse_reg(src, &mode, &num, dst);
-
- if(len) {
- src += len;
- if (*src == '+')
+ if (*src == '@')
+ {
+ src++;
+ src = parse_exp (src, &op->exp);
+
+ src = skip_colonthing (src, &op->exp, &op->mode);
+
+ *ptr = src;
+
+ op->mode = MEMIND;
+ return;
+
+ }
+
+
+ if (*src == '-')
{
src++;
- if (mode != RS16)
- {
- as_bad("@Rn+ needs src word register");
- return;
- }
- op->mode = RSINC;
+ len = parse_reg (src, &mode, &num, direction);
+ if (len == 0)
+ {
+ /* Oops, not a reg after all, must be ordinary exp */
+ src--;
+ /* must be a symbol */
+ op->mode = ABS | PSIZE | direction;
+ *ptr = skip_colonthing (parse_exp (src, &op->exp),
+ &op->exp, &op->mode);
+
+ return;
+
+
+ }
+
+
+ if ((mode & SIZE) != PSIZE)
+ as_bad ("Wrong size pointer register for architecture.");
+ op->mode = RDDEC;
+ op->reg = num;
+ *ptr = src + len;
+ return;
+ }
+ if (*src == '(' )
+ {
+ /* Disp */
+ src++;
+
+ /* Start off assuming a 16 bit offset */
+
+
+ src = parse_exp (src, &op->exp);
+
+ src = colonmod24 (op, src);
+
+ if (*src == ')')
+ {
+ src++;
+ op->mode = DISP | direction;
+ *ptr = src;
+ return;
+ }
+
+ if (*src != ',')
+ {
+ as_bad ("expected @(exp, reg16)");
+ return;
+
+ }
+ src++;
+
+ len = parse_reg (src, &mode, &op->reg, direction);
+ if (len == 0 || !(mode & REG))
+ {
+ as_bad ("expected @(exp, reg16)");
+ return;
+ }
+ op->mode |= DISP | direction;
+ dispreg = op->reg;
+ src += len;
+ src = skip_colonthing (src, &op->exp, &op->mode);
+
+ if (*src != ')' && '(')
+ {
+ as_bad ("expected @(exp, reg16)");
+ return;
+ }
+ *ptr = src + 1;
+
+ return;
+ }
+ len = parse_reg (src, &mode, &num, direction);
+
+ if (len)
+ {
+ src += len;
+ if (*src == '+')
+ {
+ src++;
+ if ((mode & SIZE) != PSIZE)
+ as_bad ("Wrong size pointer register for architecture.");
+ op->mode = RSINC;
+ op->reg = num;
+ *ptr = src;
+ return;
+ }
+ if ((mode & SIZE) != PSIZE)
+ as_bad ("Wrong size pointer register for architecture.");
+
+ op->mode = direction | IND | PSIZE;
op->reg = num;
*ptr = src;
+
return;
}
- if (mode != r16_sord[dst])
+ else
{
- as_bad("@Rn needs word register");
+ /* must be a symbol */
+
+ op->mode = ABS | direction;
+ src = parse_exp (src, &op->exp);
+
+ *ptr = colonmod24 (op, src);
+
return;
-
}
- op->mode =rind_sord[dst];
- op->reg = num;
- *ptr = src;
-
- return;
- }
- else
- {
- /* must be a symbol */
- op->mode = abs_sord[dst];
- *ptr = skip_colonthing(parse_exp(src, &op->exp));
-
- return;
}
- }
-
-
- if (*src == '#') {
+
+
+ if (*src == '#')
+ {
src++;
- op->mode = IMM16;
- src = parse_exp(src, &op->exp);
- *ptr= skip_colonthing(src);
-
+ op->mode = IMM;
+ src = parse_exp (src, &op->exp);
+ *ptr = skip_colonthing (src, &op->exp, &op->mode);
+
return;
}
- else {
- *ptr = parse_exp(src, &op->exp);
- op->mode = DISP8;
+ else
+ {
+ src = parse_exp (src, &op->exp);
+ /* Trailing ':' size ? */
+ if (*src == ':')
+ {
+ if (src[1] == '1' && src[2] == '6')
+ {
+ op->mode = PCREL | L_16;
+ src += 3;
+ }
+ else if (src[1] == '8')
+ {
+ op->mode = PCREL | L_8;
+ src += 2;
+ }
+ else
+ {
+ as_bad ("expect :8 or :16 here");
+ }
+ }
+ else
+ {
+ op->mode = PCREL | bsize;
+ }
+ *ptr = src;
}
}
static
- char *
- DEFUN(get_operands,(noperands,op_end, operand),
- unsigned int noperands AND
- char *op_end AND
- struct h8_op *operand)
+char *
+DEFUN (get_operands, (noperands, op_end, operand),
+ unsigned int noperands AND
+ char *op_end AND
+ struct h8_op *operand)
{
- char *ptr = op_end;
- switch (noperands)
- {
- case 0:
- operand[0].mode = 0;
- operand[1].mode = 0;
- break;
-
- case 1:
- ptr++;
- get_operand(& ptr, operand +0,0);
- operand[1].mode =0;
- break;
-
- case 2:
- ptr++;
- get_operand(& ptr, operand +0,0);
- if (*ptr == ',') ptr++;
- get_operand(& ptr, operand +1, 1);
- break;
-
- default:
- abort();
- }
-
-
- return ptr;
+ char *ptr = op_end;
+
+ switch (noperands)
+ {
+ case 0:
+ operand[0].mode = 0;
+ operand[1].mode = 0;
+ break;
+
+ case 1:
+ ptr++;
+ get_operand (&ptr, operand + 0, 0, SRC);
+ if (*ptr == ',')
+ {
+ ptr++;
+ get_operand (&ptr, operand + 1, 1, DST);
+ }
+ else
+ {
+ operand[1].mode = 0;
+ }
+
+ break;
+ case 2:
+ ptr++;
+ get_operand (&ptr, operand + 0, 0, SRC);
+ if (*ptr == ',')
+ ptr++;
+ get_operand (&ptr, operand + 1, 1, DST);
+ break;
+
+ default:
+ abort ();
+ }
+
+
+ return ptr;
}
/* Passed a pointer to a list of opcodes which use different
provided
*/
static
- struct h8_opcode *
- DEFUN(get_specific,(opcode, operands),
- struct h8_opcode *opcode AND
- struct h8_op *operands)
-
+struct h8_opcode *
+get_specific (opcode, operands)
+ struct h8_opcode *opcode;
+ struct h8_op *operands;
{
- struct h8_opcode *this_try = opcode ;
- int found = 0;
- unsigned int noperands = opcode->noperands;
-
- unsigned int dispreg;
- unsigned int this_index = opcode->idx;
- while (this_index == opcode->idx && !found)
+ struct h8_opcode *this_try = opcode;
+ int found = 0;
+
+ unsigned int this_index = opcode->idx;
+
+ while (this_index == opcode->idx && !found)
+ {
+ unsigned int i;
+ found = 1;
+
+ this_try = opcode++;
+ for (i = 0; i < this_try->noperands && found; i++)
+ {
+ op_type op = this_try->args.nib[i];
+ int x = operands[i].mode;
+
+ if ((op & (DISP | REG)) == (DISP | REG)
+ && ((x & DISP | REG) == (DISP | REG)))
{
- unsigned int i;
-
- this_try = opcode ++;
- for (i = 0; i < noperands; i++)
- {
- op_type op = (this_try->args.nib[i]) & ~(B30|B31);
- switch (op)
- {
- case Hex0:
- case Hex1:
- case Hex2:
- case Hex3:
- case Hex4:
- case Hex5:
- case Hex6:
- case Hex7:
- case Hex8:
- case Hex9:
- case HexA:
- case HexB:
- case HexC:
- case HexD:
- case HexE:
- case HexF:
- break;
- case DISPSRC:
- case DISPDST:
- operands[0].dispreg = operands[i].reg;
- case RD8:
- case RS8:
- case RDIND:
- case RSIND:
- case RD16:
- case RS16:
- case CCR:
- case RSINC:
- case RDDEC:
- if (operands[i].mode != op) goto fail;
- break;
- case KBIT:
- case IMM16:
- case IMM3:
- case IMM8:
- if (operands[i].mode != IMM16) goto fail;
- break;
- case MEMIND:
- if (operands[i].mode != MEMIND) goto fail;
- break;
- case ABS16SRC:
- case ABS8SRC:
- case ABS16OR8SRC:
- case ABS16ORREL8SRC:
-
- if (operands[i].mode != ABS16SRC) goto fail;
- break;
- case ABS16OR8DST:
- case ABS16DST:
- case ABS8DST:
- if (operands[i].mode != ABS16DST) goto fail;
- break;
- }
- }
- found =1;
- fail: ;
+ dispreg = operands[i].reg;
}
- if (found)
- return this_try;
- else
- return 0;
+ else if (op & REG)
+ {
+ if (!(x & REG))
+ found = 0;
+
+ if (x & L_P)
+ {
+ x = (x & ~L_P) | (Hmode ? L_32 : L_16);
+ }
+ if (op & L_P)
+ {
+ op = (op & ~L_P) | (Hmode ? L_32 : L_16);
+ }
+
+ opsize = op & SIZE;
+
+ /* The size of the reg is v important */
+ if ((op & SIZE) != (x & SIZE))
+ found = 0;
+ }
+ else if ((op & ABSJMP) && (x & ABS))
+ {
+ operands[i].mode &= ~ABS;
+ operands[i].mode |= ABSJMP;
+ /* But it may not be 24 bits long */
+ if (!Hmode)
+ {
+ operands[i].mode &= ~SIZE;
+ operands[i].mode |= L_16;
+ }
+
+
+ }
+ else if ((op & (KBIT | DBIT)) && (x & IMM))
+ {
+ /* This is ok if the immediate value is sensible */
+
+ }
+ else if (op & PCREL)
+ {
+
+ /* The size of the displacement is important */
+ if ((op & SIZE) != (x & SIZE))
+ found = 0;
+
+ }
+ else if ((op & (DISP | IMM | ABS))
+ && (op & (DISP | IMM | ABS)) == (x & (DISP | IMM | ABS)))
+ {
+ /* Got a diplacement,will fit if no size or same size as try */
+ if ((x & SIZE) != 0
+ && ((op & SIZE) != (x & SIZE)))
+ found = 0;
+ }
+ else if ((op & ABSMOV) && (x & ABS))
+ {
+ /* Ok */
+ }
+ else if ((op & MODE) != (x & MODE))
+ {
+ found = 0;
+ }
+
+ }
+ }
+ if (found)
+ return this_try;
+ else
+ return 0;
}
static void
- DEFUN(check_operand,(operand, width, string),
- struct h8_op *operand AND
- unsigned int width AND
- char *string)
+DEFUN (check_operand, (operand, width, string),
+ struct h8_op *operand AND
+ unsigned int width AND
+ char *string)
{
- if (operand->exp.X_add_symbol == 0
+ if (operand->exp.X_add_symbol == 0
&& operand->exp.X_subtract_symbol == 0)
- {
-
- /* No symbol involved, let's look at offset, it's dangerous if any of
- the high bits are not 0 or ff's, find out by oring or anding with
- the width and seeing if the answer is 0 or all fs*/
- if ((operand->exp.X_add_number & ~width) != 0 &&
- (operand->exp.X_add_number | width)!= (~0))
{
- as_warn("operand %s0x%x out of range.", string, operand->exp.X_add_number);
+
+ /* No symbol involved, let's look at offset, it's dangerous if any of
+ the high bits are not 0 or ff's, find out by oring or anding with
+ the width and seeing if the answer is 0 or all fs*/
+ if ((operand->exp.X_add_number & ~width) != 0 &&
+ (operand->exp.X_add_number | width) != (~0))
+ {
+ as_warn ("operand %s0x%x out of range.", string, operand->exp.X_add_number);
+ }
}
- }
-
+
+}
+
+static void
+do_a_fix_imm (offset, operand, relaxing)
+ int offset;
+ struct h8_op *operand;
+ int relaxing;
+{
+ int idx;
+ int size;
+ int where;
+
+
+ char *t = operand->mode & IMM ? "#" : "@";
+
+ if (operand->exp.X_add_symbol == 0)
+ {
+ char *bytes = frag_now->fr_literal + offset;
+ switch (operand->mode & SIZE)
+ {
+ case L_3:
+ check_operand (operand, 0x7, t);
+ bytes[0] |= (operand->exp.X_add_number) << 4;
+ break;
+ case L_8:
+ check_operand (operand, 0xff, t);
+ bytes[0] = operand->exp.X_add_number;
+ break;
+ case L_16:
+ check_operand (operand, 0xffff, t);
+ bytes[0] = operand->exp.X_add_number >> 8;
+ bytes[1] = operand->exp.X_add_number >> 0;
+ break;
+ case L_24:
+ check_operand (operand, 0xffffff, t);
+ bytes[0] = operand->exp.X_add_number >> 16;
+ bytes[1] = operand->exp.X_add_number >> 8;
+ bytes[2] = operand->exp.X_add_number >> 0;
+ break;
+
+ case L_32:
+ /* This should be done with bfd */
+ bytes[0] = operand->exp.X_add_number >> 24;
+ bytes[1] = operand->exp.X_add_number >> 16;
+ bytes[2] = operand->exp.X_add_number >> 8;
+ bytes[3] = operand->exp.X_add_number >> 0;
+ break;
+ }
+
+ }
+ else
+ {
+ switch (operand->mode & SIZE)
+ {
+ default:
+ abort ();
+ case L_24:
+ size = 4;
+ where = -1;
+ idx = relaxing ? R_MOVLB1 : R_RELLONG;
+ break;
+
+ case L_32:
+ size = 4;
+ where = 0;
+ idx = R_RELLONG;
+ break;
+ case L_16:
+ size = 2;
+ where = 0;
+ idx = relaxing ? R_MOVB1 : R_RELWORD;
+ break;
+ case L_8:
+ size = 1;
+ where = 0;
+ idx = R_RELBYTE;
+ }
+
+
+ fix_new (frag_now,
+ offset + where,
+ size,
+ operand->exp.X_add_symbol,
+ operand->exp.X_subtract_symbol,
+ (short) (operand->exp.X_add_number),
+ 0,
+ idx);
+ }
+
}
/* Now we know what sort of opcodes it is, lets build the bytes -
*/
-static void
- DEFUN (build_bytes,(this_try, operand),
- struct h8_opcode *this_try AND
- struct h8_op *operand)
-
+static void
+build_bytes (this_try, operand)
+ struct h8_opcode *this_try;
+ struct h8_op *operand;
{
- unsigned int i;
-
- char *output = frag_more(this_try->length);
- char *output_ptr = output;
- op_type *nibble_ptr = this_try->data.nib;
- char part;
- op_type c;
- char high;
- int nib;
- top: ;
- while (*nibble_ptr != E)
+ unsigned int i;
+
+ char *output = frag_more (this_try->length);
+ char *output_ptr = output;
+ op_type *nibble_ptr = this_try->data.nib;
+ char part;
+ op_type c;
+ char high;
+ unsigned int nibble_count = 0;
+
+ int immat;
+ int nib;
+ char asnibbles[30];
+ char *p = asnibbles;
+
+ if (!(this_try->inbase || Hmode))
+ {
+ as_warn ("Opcode `%s' only available on H8/300-H", this_try->name);
+ }
+
+ while (*nibble_ptr != E)
+ {
+ int d;
+ c = *nibble_ptr++;
+
+ d = (c & DST) != 0;
+
+ if (c < 16)
+ {
+ nib = c;
+ }
+ else
+ {
+
+ if (c & (REG | IND | INC | DEC))
{
- int nibble;
- for (nibble = 0; nibble <2; nibble++)
- {
- c = *nibble_ptr & ~(B30|B31);
- switch (c)
- {
- default:
- abort();
- case KBIT:
- switch (operand[0].exp.X_add_number)
- {
- case 1:
- nib = 0;
- break;
- case 2:
- nib = 8;
- break;
- default:
- as_bad("Need #1 or #2 here");
- break;
- }
- /* stop it making a fix */
- operand[0].mode = 0;
- break;
- case 0:
- case 1:
- case 2: case 3: case 4: case 5: case 6:
- case 7: case 8: case 9: case 10: case 11:
- case 12: case 13: case 14: case 15:
- nib = c;
- break;
- case DISPREG:
- nib = operand[0].dispreg;
- break;
- case IMM8:
- operand[0].mode = IMM8;
- nib = 0;
- break;
-
- case DISPDST:
- nib = 0;
- break;
- case IMM3:
- if (operand[0].exp.X_add_symbol == 0) {
- operand[0].mode = 0; /* stop it making a fix */
- nib = (operand[0].exp.X_add_number);
- }
- else as_bad("can't have symbol for bit number");
- if (nib < 0 || nib > 7)
- {
- as_bad("Bit number out of range %d", nib);
- }
-
- break;
-
- case ABS16DST:
- nib = 0;
- break;
- case ABS8DST:
- operand[1].mode = ABS8DST;
- nib = 0;
- break;
- case ABS8SRC:
- operand[0].mode = ABS8SRC;
- nib = 0;
- break;
- case ABS16OR8DST:
- operand[1].mode = c;
-
- nib = 0;
-
- break;
-
- case ABS16ORREL8SRC:
- operand[0].mode = c;
- nib=0;
- break;
-
- case ABS16OR8SRC:
- operand[0].mode = ABS16OR8SRC;
- nib = 0;
- break;
- case DISPSRC:
- operand[0].mode = ABS16SRC;
- nib = 0;
- break;
-
- case DISP8:
- operand[0].mode = DISP8;
- nib = 0;
- break;
-
- case ABS16SRC:
- case IMM16:
- case IGNORE:
- case MEMIND:
-
- nib=0;
- break;
- case RS8:
- case RS16:
- case RSIND:
- case RSINC:
- nib = operand[0].reg;
- break;
-
- case RD8:
- case RD16:
- case RDDEC:
- case RDIND:
- nib = operand[1].reg;
- break;
-
- case E:
- abort();
- break;
- }
- if (*nibble_ptr & B31) {
- nib |=0x8;
- }
-
- if (nibble == 0) {
- *output_ptr = nib << 4;
- }
- else {
- *output_ptr |= nib;
- output_ptr++;
- }
- nibble_ptr++;
- }
-
+ nib = operand[d].reg;
}
-
- /* output any fixes */
- for (i = 0; i < 2; i++)
+ else if ((c & DISPREG) == (DISPREG))
{
- switch (operand[i].mode) {
- case 0:
- break;
-
- case DISP8:
- check_operand(operand+i, 0x7f,"@");
-
- if (operand[i].exp.X_add_number & 1) {
- as_warn("branch operand has odd offset (%x)\n",
- operand->exp.X_add_number);
- }
-
- fix_new(frag_now,
- output - frag_now->fr_literal + 1,
- 1,
- operand[i].exp.X_add_symbol,
- operand[i].exp.X_subtract_symbol,
- operand[i].exp.X_add_number -1,
- 1,
- R_PCRBYTE);
- break;
- case IMM8:
- check_operand(operand+i, 0xff,"#");
- /* If there is nothing else going on we can safely
- reloc in place */
- if (operand[i].exp.X_add_symbol == 0)
- {
- output[1] = operand[i].exp.X_add_number;
- }
- else
- {
- fix_new(frag_now,
- output - frag_now->fr_literal + 1,
- 1,
- operand[i].exp.X_add_symbol,
- operand[i].exp.X_subtract_symbol,
- operand[i].exp.X_add_number,
- 0,
- R_RELBYTE);
- }
-
- break;
- case MEMIND:
- check_operand(operand+i, 0xff,"@@");
- fix_new(frag_now,
- output - frag_now->fr_literal + 1,
- 1,
- operand[i].exp.X_add_symbol,
- operand[i].exp.X_subtract_symbol,
- operand[i].exp.X_add_number,
- 0,
- R_RELBYTE);
- break;
- case ABS8DST:
- case ABS8SRC:
- check_operand(operand+i, 0xff,"@");
- fix_new(frag_now,
- output - frag_now->fr_literal + 1,
- 1,
- operand[i].exp.X_add_symbol,
- operand[i].exp.X_subtract_symbol,
- operand[i].exp.X_add_number,
- 0,
- R_RELBYTE);
- break;
-
- case ABS16OR8SRC:
- case ABS16OR8DST:
- check_operand(operand+i, 0xffff,"@");
-
- fix_new(frag_now,
- output - frag_now->fr_literal + 2,
- 2,
- operand[i].exp.X_add_symbol,
- operand[i].exp.X_subtract_symbol,
- operand[i].exp.X_add_number,
- 0,
- R_MOVB1);
- break;
-
- case ABS16ORREL8SRC:
- check_operand(operand+i, 0xffff,"@");
- if (operand[i].exp.X_add_number & 1) {
- as_warn("branch operand has odd offset (%x)\n",
- operand->exp.X_add_number);
- }
- fix_new(frag_now,
- output - frag_now->fr_literal + 2,
- 2,
- operand[i].exp.X_add_symbol,
- operand[i].exp.X_subtract_symbol,
- operand[i].exp.X_add_number,
- 0,
- R_JMP1);
- break;
-
-
- case ABS16SRC:
- case ABS16DST:
- case IMM16:
- case DISPSRC:
- case DISPDST:
- check_operand(operand+i, 0xffff,"@");
- if (operand[i].exp.X_add_symbol == 0)
- {
- /* This should be done with bfd */
- output[3] = operand[i].exp.X_add_number & 0xff;
- output[2] = operand[i].exp.X_add_number >> 8;
-
- }
- else
- {
-
- fix_new(frag_now,
- output - frag_now->fr_literal + 2,
- 2,
- operand[i].exp.X_add_symbol,
- operand[i].exp.X_subtract_symbol,
- operand[i].exp.X_add_number,
- 0,
- R_RELWORD);
- }
-
- break;
- case RS8:
- case RD8:
- case RS16:
- case RD16:
- case RDDEC:
- case KBIT:
- case RSINC:
- case RDIND:
- case RSIND:
- case CCR:
-
- break;
- default:
- abort();
- }
+ nib = dispreg;
}
-
-}
-/*
- try and give an intelligent error message for common and simple to
- detect errors
- */
-static void
- DEFUN(clever_message, (opcode, operand),
- struct h8_opcode *opcode AND
- struct h8_op *operand)
-{
- struct h8_opcode *scan = opcode;
-
- /* Find out if there was more than one possible opccode */
-
- if ((opcode+1)->idx != opcode->idx)
- {
- unsigned int argn;
-
- /* Only one opcode of this flavour, try and guess which operand
- didn't match */
- for (argn = 0; argn < opcode->noperands; argn++)
+ else if (c & ABSMOV)
+ {
+ operand[d].mode &= ~ABS;
+ operand[d].mode |= ABSMOV;
+ immat = nibble_count / 2;
+ nib = 0;
+ }
+ else if (c & (IMM | PCREL | ABS | ABSJMP | DISP ))
+ {
+ operand[d].mode = c;
+ immat = nibble_count / 2;
+ nib = 0;
+ }
+ else if (c & IGNORE)
+ {
+ nib = 0;
+ }
+ else if (c & DBIT)
+ {
+ switch (operand[0].exp.X_add_number)
+ {
+ case 1:
+ nib = c;
+ break;
+ case 2:
+ nib = 0x8 | c;
+ break;
+ default:
+ as_bad ("Need #1 or #2 here");
+ }
+ }
+ else if (c & KBIT)
+ {
+ switch (operand[0].exp.X_add_number)
+ {
+ case 1:
+ nib = 0;
+ break;
+ case 2:
+ nib = 8;
+ break;
+ case 4:
+ if (!Hmode)
+ as_warn ("#4 only valid in h8/300 mode.");
+ nib = 9;
+ break;
+
+ default:
+ as_bad ("Need #1 or #2 here");
+ break;
+ }
+ /* stop it making a fix */
+ operand[0].mode = 0;
+ }
+
+ if (c & B31)
+ {
+ nib |= 0x8;
+ }
+ }
+ nibble_count++;
+
+ *p++ = nib;
+ }
+
+ for (i = 0; i < this_try->length; i++)
+ {
+ output[i] = (asnibbles[i * 2] << 4) | asnibbles[i * 2 + 1];
+ }
+
+ /* output any fixes */
+ for (i = 0; i < 2; i++)
{
- switch (opcode->args.nib[argn])
- {
- case RD16:
- if (operand[argn].mode != RD16)
+ int x = operand[i].mode;
+
+ if (x & (IMM | ABS | DISP))
{
- as_bad("destination operand must be 16 bit register");
- return;
-
+ do_a_fix_imm (output - frag_now->fr_literal + immat, operand + i,0);
}
- break;
-
- case RS8:
-
- if (operand[argn].mode != RS8)
+ else if (x & PCREL)
{
- as_bad("source operand must be 8 bit register");
- return;
+ int size16 = x & L_16;
+ int where = size16 ? 2 : 1;
+ int size = size16 ? 2 : 1;
+ int type = size16 ? R_PCRWORD : R_PCRBYTE;
+
+ check_operand (operand + i, size16 ? 0x7fff : 0x7f, "@");
+
+ if (operand[i].exp.X_add_number & 1)
+ {
+ as_warn ("branch operand has odd offset (%x)\n",
+ operand->exp.X_add_number);
+ }
+
+ fix_new (frag_now,
+ output - frag_now->fr_literal + where,
+ size,
+ operand[i].exp.X_add_symbol,
+ operand[i].exp.X_subtract_symbol,
+ (char) (operand[i].exp.X_add_number - 1),
+ 1,
+ type);
}
- break;
-
- case ABS16DST:
- if (operand[argn].mode != ABS16DST)
+ else if (x & MEMIND)
{
- as_bad("destination operand must be 16bit absolute address");
- return;
+
+ check_operand (operand + i, 0xff, "@@");
+ fix_new (frag_now,
+ output - frag_now->fr_literal + 1,
+ 1,
+ operand[i].exp.X_add_symbol,
+ operand[i].exp.X_subtract_symbol,
+ operand[i].exp.X_add_number,
+ 0,
+ R_RELBYTE);
}
-break;
- case RD8:
- if (operand[argn].mode != RD8)
+
+ else if (x & ABSMOV)
{
- as_bad("destination operand must be 8 bit register");
- return;
+ /* This mov is either absolute long or thru a memory loc */
+ do_a_fix_imm (output - frag_now->fr_literal + immat, operand + i,1);
}
- break;
-
-
- case ABS16SRC:
- if (operand[argn].mode != ABS16SRC)
+
+ else if (x & ABSJMP)
{
- as_bad("source operand must be 16bit absolute address");
- return;
+ /* This jmp may be a jump or a branch */
+
+ check_operand (operand + i, Hmode ? 0xfffff : 0xffff, "@");
+ if (operand[i].exp.X_add_number & 1)
+ {
+ as_warn ("branch operand has odd offset (%x)\n",
+ operand->exp.X_add_number);
+ }
+ fix_new (frag_now,
+ output - frag_now->fr_literal,
+ 4,
+ operand[i].exp.X_add_symbol,
+ operand[i].exp.X_subtract_symbol,
+ (short) (operand[i].exp.X_add_number),
+ 0,
+ R_JMPL1);
}
- break;
-
- }
}
- }
- as_bad("invalid operands");
+
+}
+
+/*
+ try and give an intelligent error message for common and simple to
+ detect errors
+ */
+
+static void
+DEFUN (clever_message, (opcode, operand),
+ struct h8_opcode *opcode AND
+ struct h8_op *operand)
+{
+ struct h8_opcode *scan = opcode;
+
+ /* Find out if there was more than one possible opccode */
+
+ if ((opcode + 1)->idx != opcode->idx)
+ {
+ unsigned int argn;
+
+ /* Only one opcode of this flavour, try and guess which operand
+ didn't match */
+ for (argn = 0; argn < opcode->noperands; argn++)
+ {
+ switch (opcode->args.nib[argn])
+ {
+ case RD16:
+ if (operand[argn].mode != RD16)
+ {
+ as_bad ("destination operand must be 16 bit register");
+ return;
+
+ }
+ break;
+
+ case RS8:
+
+ if (operand[argn].mode != RS8)
+ {
+ as_bad ("source operand must be 8 bit register");
+ return;
+ }
+ break;
+
+ case ABS16DST:
+ if (operand[argn].mode != ABS16DST)
+ {
+ as_bad ("destination operand must be 16bit absolute address");
+ return;
+ }
+ break;
+ case RD8:
+ if (operand[argn].mode != RD8)
+ {
+ as_bad ("destination operand must be 8 bit register");
+ return;
+ }
+ break;
+
+
+ case ABS16SRC:
+ if (operand[argn].mode != ABS16SRC)
+ {
+ as_bad ("source operand must be 16bit absolute address");
+ return;
+ }
+ break;
+
+ }
+ }
+ }
+ as_bad ("invalid operands");
}
/* This is the guts of the machine-dependent assembler. STR points to a
-void
- DEFUN(md_assemble,(str),
- char *str)
+void
+DEFUN (md_assemble, (str),
+ char *str)
{
- char *op_start;
- char *op_end;
- unsigned int i;
- struct h8_op operand[2];
- struct h8_opcode * opcode;
- struct h8_opcode * prev_opcode;
-
- char *dot = 0;
- char c;
- /* Drop leading whitespace */
- while (*str == ' ')
- str++;
-
- /* find the op code end */
- for (op_start = op_end = str;
- *op_end != 0 && *op_end != ' ';
- op_end ++)
- {
- if (*op_end == '.') {
- dot = op_end+1;
- *op_end = 0;
- op_end+=2;
- break;
- }
- }
-
- ;
-
- if (op_end == op_start)
- {
- as_bad("can't find opcode ");
- }
- c = *op_end;
-
- *op_end = 0;
-
- opcode = (struct h8_opcode *) hash_find(opcode_hash_control,
- op_start);
-
- if (opcode == NULL)
- {
- as_bad("unknown opcode");
- return;
- }
-
-
- input_line_pointer = get_operands(opcode->noperands, op_end,
- operand);
- *op_end = c;
- prev_opcode = opcode;
-
- opcode = get_specific(opcode, operand);
-
- if (opcode == 0)
- {
- /* Couldn't find an opcode which matched the operands */
- char *where =frag_more(2);
- where[0] = 0x0;
- where[1] = 0x0;
- clever_message(prev_opcode, operand);
-
- return;
- }
- if (opcode->size && dot)
- {
- if (opcode->size != *dot)
- {
- as_warn("mismatch between opcode size and operand size");
- }
- }
-
- build_bytes(opcode, operand);
-
+ char *op_start;
+ char *op_end;
+ unsigned int i;
+ struct h8_op operand[2];
+ struct h8_opcode *opcode;
+ struct h8_opcode *prev_opcode;
+
+ char *dot = 0;
+ char c;
+
+ /* Drop leading whitespace */
+ while (*str == ' ')
+ str++;
+
+ /* find the op code end */
+ for (op_start = op_end = str;
+ *op_end != 0 && *op_end != ' ';
+ op_end++)
+ {
+ if (*op_end == '.')
+ {
+ dot = op_end + 1;
+ *op_end = 0;
+ op_end += 2;
+ break;
+ }
+ }
+
+ ;
+
+ if (op_end == op_start)
+ {
+ as_bad ("can't find opcode ");
+ }
+ c = *op_end;
+
+ *op_end = 0;
+
+ opcode = (struct h8_opcode *) hash_find (opcode_hash_control,
+ op_start);
+
+ if (opcode == NULL)
+ {
+ as_bad ("unknown opcode");
+ return;
+ }
+
+
+ input_line_pointer = get_operands (opcode->noperands, op_end,
+ operand);
+ *op_end = c;
+ prev_opcode = opcode;
+
+ opcode = get_specific (opcode, operand);
+
+ if (opcode == 0)
+ {
+ /* Couldn't find an opcode which matched the operands */
+ char *where = frag_more (2);
+
+ where[0] = 0x0;
+ where[1] = 0x0;
+ clever_message (prev_opcode, operand);
+
+ return;
+ }
+ if (opcode->size && dot)
+ {
+ if (opcode->size != *dot)
+ {
+ as_warn ("mismatch between opcode size and operand size");
+ }
+ }
+
+ build_bytes (opcode, operand);
+
}
-void
- DEFUN(tc_crawl_symbol_chain, (headers),
- object_headers *headers)
+void
+DEFUN (tc_crawl_symbol_chain, (headers),
+ object_headers * headers)
{
- printf("call to tc_crawl_symbol_chain \n");
+ printf ("call to tc_crawl_symbol_chain \n");
}
-symbolS *DEFUN(md_undefined_symbol,(name),
- char *name)
+symbolS *
+DEFUN (md_undefined_symbol, (name),
+ char *name)
{
- return 0;
+ return 0;
}
-void
- DEFUN(tc_headers_hook,(headers),
- object_headers *headers)
+void
+DEFUN (tc_headers_hook, (headers),
+ object_headers * headers)
{
- printf("call to tc_headers_hook \n");
+ printf ("call to tc_headers_hook \n");
}
+
void
- DEFUN_VOID(md_end)
+DEFUN_VOID (md_end)
{
}
emitted is stored in *sizeP . An error message is returned, or NULL on OK.
*/
char *
- md_atof(type,litP,sizeP)
-char type;
-char *litP;
-int *sizeP;
+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 */
+ 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 "";
}
int
- md_parse_option(argP, cntP, vecP)
-char **argP;
-int *cntP;
-char ***vecP;
+md_parse_option (argP, cntP, vecP)
+ char **argP;
+ int *cntP;
+ char ***vecP;
{
- return 0;
-
+ return 0;
+
}
int md_short_jump_size;
-void tc_aout_fix_to_chars () { printf("call to tc_aout_fix_to_chars \n");
- abort(); }
-void md_create_short_jump(ptr, from_addr, to_addr, frag, to_symbol)
-char *ptr;
-long from_addr;
-long to_addr;
-fragS *frag;
-symbolS *to_symbol;
+void
+tc_aout_fix_to_chars ()
+{
+ printf ("call to tc_aout_fix_to_chars \n");
+ abort ();
+}
+
+void
+md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
+ char *ptr;
+ addressT from_addr;
+ addressT to_addr;
+ fragS *frag;
+ symbolS *to_symbol;
{
- as_fatal("failed sanity check.");
+ as_fatal ("failed sanity check.");
}
void
- md_create_long_jump(ptr,from_addr,to_addr,frag,to_symbol)
-char *ptr;
-long from_addr, to_addr;
-fragS *frag;
-symbolS *to_symbol;
+md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
+ char *ptr;
+ addressT from_addr, to_addr;
+ fragS *frag;
+ symbolS *to_symbol;
{
- as_fatal("failed sanity check.");
+ as_fatal ("failed sanity check.");
}
void
- md_convert_frag(headers, fragP)
-object_headers *headers;
-fragS * fragP;
+md_convert_frag (headers, fragP)
+ object_headers *headers;
+ fragS *fragP;
-{ printf("call to md_convert_frag \n"); abort(); }
+{
+ printf ("call to md_convert_frag \n");
+ abort ();
+}
-long
- DEFUN(md_section_align,(seg, size),
- segT seg AND
- long size)
+valueT
+DEFUN (md_section_align, (seg, size),
+ segT seg AND
+ valueT size)
{
- return((size + (1 << section_alignment[(int) seg]) - 1) & (-1 << section_alignment[(int) seg]));
-
+ return ((size + (1 << section_alignment[(int) seg]) - 1) & (-1 << section_alignment[(int) seg]));
+
}
void
- md_apply_fix(fixP, val)
-fixS *fixP;
-long val;
+md_apply_fix (fixP, val)
+ fixS *fixP;
+ long val;
{
- char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
-
- switch(fixP->fx_size) {
- case 1:
- *buf++=val;
- break;
- case 2:
- *buf++=(val>>8);
- *buf++=val;
- break;
- case 4:
- *buf++=(val>>24);
- *buf++=(val>>16);
- *buf++=(val>>8);
- *buf++=val;
- break;
- default:
- abort();
-
- }
+ char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
+
+ switch (fixP->fx_size)
+ {
+ case 1:
+ *buf++ = val;
+ break;
+ case 2:
+ *buf++ = (val >> 8);
+ *buf++ = val;
+ break;
+ case 4:
+ *buf++ = (val >> 24);
+ *buf++ = (val >> 16);
+ *buf++ = (val >> 8);
+ *buf++ = val;
+ break;
+ default:
+ abort ();
+
+ }
}
-void DEFUN(md_operand, (expressionP),expressionS *expressionP)
-{ }
+void
+DEFUN (md_operand, (expressionP), expressionS * expressionP)
+{
+}
-int md_long_jump_size;
+int md_long_jump_size;
int
- md_estimate_size_before_relax(fragP, segment_type)
-register fragS *fragP;
-register segT segment_type;
-{
- printf("call tomd_estimate_size_before_relax \n"); abort(); }
+md_estimate_size_before_relax (fragP, segment_type)
+ register fragS *fragP;
+ register segT segment_type;
+{
+ printf ("call tomd_estimate_size_before_relax \n");
+ abort ();
+}
+
/* Put number into target byte order */
-void DEFUN(md_number_to_chars,(ptr, use, nbytes),
- char *ptr AND
- long use AND
- int nbytes)
+void
+DEFUN (md_number_to_chars, (ptr, use, nbytes),
+ char *ptr AND
+ valueT use AND
+ int nbytes)
{
- switch (nbytes) {
- case 4: *ptr++ = (use >> 24) & 0xff;
- case 3: *ptr++ = (use >> 16) & 0xff;
- case 2: *ptr++ = (use >> 8) & 0xff;
- case 1: *ptr++ = (use >> 0) & 0xff;
- break;
- default:
- abort();
- }
+ switch (nbytes)
+ {
+ case 4:
+ *ptr++ = (use >> 24) & 0xff;
+ case 3:
+ *ptr++ = (use >> 16) & 0xff;
+ case 2:
+ *ptr++ = (use >> 8) & 0xff;
+ case 1:
+ *ptr++ = (use >> 0) & 0xff;
+ break;
+ default:
+ abort ();
+ }
+}
+long
+md_pcrel_from (fixP)
+ fixS *fixP;
+{
+ abort ();
}
-long md_pcrel_from(fixP)
-fixS *fixP; { abort(); }
-void tc_coff_symbol_emit_hook() { }
+void
+tc_coff_symbol_emit_hook ()
+{
+}
-void tc_reloc_mangle(fix_ptr, intr, base)
-fixS *fix_ptr;
-struct internal_reloc *intr;
-bfd_vma base;
+void
+tc_reloc_mangle (fix_ptr, intr, base)
+ fixS *fix_ptr;
+ struct internal_reloc *intr;
+ bfd_vma base;
{
- symbolS *symbol_ptr;
-
- symbol_ptr = fix_ptr->fx_addsy;
-
- /* If this relocation is attached to a symbol then it's ok
- to output it */
- if (fix_ptr->fx_r_type == RELOC_32) {
- /* cons likes to create reloc32's whatever the size of the reloc..
- */
- switch (fix_ptr->fx_size)
- {
-
- case 2:
- intr->r_type = R_RELWORD;
- break;
- case 1:
- intr->r_type = R_RELBYTE;
- break;
- default:
- abort();
-
- }
-
- }
- else {
- intr->r_type = fix_ptr->fx_r_type;
+ symbolS *symbol_ptr;
+
+ symbol_ptr = fix_ptr->fx_addsy;
+
+ /* If this relocation is attached to a symbol then it's ok
+ to output it */
+ if (fix_ptr->fx_r_type == RELOC_32)
+ {
+ /* cons likes to create reloc32's whatever the size of the reloc..
+ */
+ switch (fix_ptr->fx_size)
+ {
+
+ case 2:
+ intr->r_type = R_RELWORD;
+ break;
+ case 1:
+ intr->r_type = R_RELBYTE;
+ break;
+ default:
+ abort ();
+
}
-
- intr->r_vaddr = fix_ptr->fx_frag->fr_address + fix_ptr->fx_where +base;
- intr->r_offset = fix_ptr->fx_offset;
-
- if (symbol_ptr)
- intr->r_symndx = symbol_ptr->sy_number;
- else
- intr->r_symndx = -1;
-
-
+
+ }
+ else
+ {
+ intr->r_type = fix_ptr->fx_r_type;
+ }
+
+ intr->r_vaddr = fix_ptr->fx_frag->fr_address + fix_ptr->fx_where + base;
+ intr->r_offset = fix_ptr->fx_offset;
+
+ if (symbol_ptr)
+ intr->r_symndx = symbol_ptr->sy_number;
+ else
+ intr->r_symndx = -1;
+
+
+}
+
+tc_coff_sizemachdep ()
+{
+ abort ();
}
/* end of tc-h8300.c */
--- /dev/null
+/* 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" */
+/*
+ * 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 ();
+
+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_big_cons, 16},
+ {"OCTA", pa_big_cons, 16},
+ {"org", pa_origin, 0},
+ {"ORG", pa_origin, 0},
+ {"origin", pa_origin, 0},
+ {"ORIGIN", pa_origin, 0},
+ {"proc", pa_proc, 0},
+ {"PROC", pa_proc, 0},
+ {"procend", pa_procend, 0},
+ {"PROCEND", pa_procend, 0},
+ {"quad", pa_big_cons, 8},
+ {"QUAD", pa_big_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 */
+ {
+ NULL, /* exp.X_add_symbol */
+ NULL, /* exp.X_subtract_symbol */
+ 0, /* exp.X_add_number */
+ NULL /* exp.asection */
+ },
+ 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;
+
+symbolS *label_symbolP; /* the last label symbol encountered */
+/* saved here in case a .equ is encountered */
+int label_symbol_defined;
+
+int callinfo_found; /* T if a .callinfo appeared within the current */
+/* procedure definition and F otherwise */
+
+int within_entry_exit; /* T if the assembler is currently within a */
+/* .entry/.exit pair and F otherwise */
+
+int exit_processing_complete; /* T is the assembler has completed exit */
+/* processing for the current procedure */
+/* and F otherwise */
+
+int within_procedure; /* T if the assembler is currently within a */
+/* a procedure definition and F otherwise */
+
+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)
+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},
+ {GDB_STRINGS, 0, 0, 0, 0, 0, 0, 254, 0x1f, 0, 4, 0, 2, ".stabstr", SUBSEG_GDB_STRINGS},
+ {GDB_SYMBOLS, 0, 0, 0, 0, 0, 0, 255, 0x1f, 0, 4, 0, 2, ".stab", SUBSEG_GDB_SYMBOLS},
+ {NULL, 0, 1, 0, 0, 0, 0, 255, 0x1f, 0, 4, 0, 0, 0}
+};
+
+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"},
+ {GDB_DEBUG_SPACE_NAME, 0, 0, 0, 0, 255, ASEC_NULL, ".stab"},
+ {NULL, 0, 0, 0, 0, 0, ASEC_NULL, NULL}
+};
+#else
+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}
+};
+
+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
+
+#ifdef USG
+#define bcmp(b1,b2,n) memcmp((b1),(b2),(n))
+#define index strchr
+#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 *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 */
+};
+
+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 */
+
+label_symbolS *label_symbols_rootP = NULL;
+
+/*
+ PA_GET_LABEL
+
+ Returns a pointer to the label_symbolS for the current space.
+ */
+
+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.
+ */
+
+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.
+ */
+
+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;
+
+hppa_fixS *hppa_fix_root = NULL;
+
+void
+fix_new_hppa (frag, where, size, add_symbol, sub_symbol, offset, 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. */
+ symbolS *sub_symbol; /* X_subtract_symbol. */
+ long offset; /* X_add_number. */
+ 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 = fix_new (frag, where, size,
+ add_symbol, sub_symbol,
+ offset, pcrel, r_type);
+
+ hppa_fixS *hppa_fix = (hppa_fixS *) obstack_alloc (¬es, sizeof (hppa_fixS));
+
+ 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
+ exp->X_add_symbol,
+ exp->X_subtract_symbol,
+ exp->X_add_number, 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 && *retval != '\0')
+ {
+ 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 */
+ the_insn.exp.X_add_symbol,
+ the_insn.exp.X_subtract_symbol,
+ the_insn.exp.X_add_number,
+ 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 */
+ the_insn.exp.X_add_symbol,
+ the_insn.exp.X_subtract_symbol,
+ the_insn.exp.X_add_number,
+ 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;
+ unsigned int mask;
+ int match = FALSE;
+ int comma = 0;
+
+ int reg, reg1, reg2, s2, s3;
+ unsigned int im21, im14, im11, im5;
+ int m, a, uu, f;
+ int cmpltr, nullif, flag;
+ int sfu, cond;
+ char *name;
+ char *p, *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 '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_seg == &bfd_abs_section)
+ {
+ 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);
+ 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);
+ if (cmpltr < 0)
+ {
+ s = save_s;
+ cmpltr = pa_parse_neg_cmpsub_cmpltr (&s);
+ 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);
+ if (cmpltr < 0)
+ {
+ s = save_s;
+ cmpltr = pa_parse_neg_add_cmpltr (&s);
+ 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);
+ if (cmpltr < 0)
+ {
+ f = 1;
+ s = save_s;
+ cmpltr = pa_parse_neg_cmpsub_cmpltr (&s);
+ 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 conditions. */
+ cmpltr = 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 (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;
+ }
+ 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 || im5 < 0)
+ {
+ 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 || im5 < 0)
+ {
+ 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_seg == &bfd_abs_section)
+ {
+ 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_seg == &bfd_abs_section)
+ {
+ 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_seg == &bfd_abs_section)
+ {
+ 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_seg == &bfd_abs_section)
+ {
+ 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_seg == &bfd_abs_section)
+ {
+ 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_seg == &bfd_abs_section)
+ {
+ 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_subtract_symbol == the_insn.exp.X_subtract_symbol &&
+ prev_insn.exp.X_seg == the_insn.exp.X_seg &&
+ 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_seg == &bfd_abs_section)
+ {
+ 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_seg == &bfd_abs_section)
+ {
+ 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 || im5 < 0)
+ {
+ 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_seg == &bfd_abs_section)
+ 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_seg == &bfd_abs_section)
+ {
+ 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;
+ int status;
+
+ 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;
+ int status;
+
+ 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;
+ int status;
+
+
+ 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;
+ }
+ error:
+ 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_subtract_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;
+
+ /* Perform some processing particular to unwind */
+ /* relocations */
+
+ if (hppa_fixP->fx_call_infop
+ && (((fixP == hppa_fixP->fx_call_infop->start_fix)
+ && (fixP->fx_addsy ==
+ hppa_fixP->fx_call_infop->start_symbol))
+ || ((fixP == hppa_fixP->fx_call_infop->end_fix)
+ && (fixP->fx_addsy ==
+ hppa_fixP->fx_call_infop->end_symbol))
+ ))
+ val += fixP->fx_addsy->sy_frag->fr_address;
+
+ 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 */
+ /* *(long *)buf = *(long *)buf & 0xffffc000; */
+ 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 */
+ /* *(long *)buf = *(long *)buf & 0xffe00000; */
+ 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 */
+ /* *(long *)buf = *(long *)buf & 0xffff800; */
+ 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);
+ /* *(long *)buf = *(long *)buf & 0xffffe002; */
+ bfd_put_32 (stdoutput,
+ bfd_get_32 (stdoutput, buf) & 0xffffe002,
+ buf);
+
+ dis_assemble_12 (result, &w1, &w);
+ result = ((w1 << 2) | w);
+ break;
+
+ case 17: /* some of the opcodes with the 'W' operand type */
+ 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 */
+ /* *(long *)buf = *(long *)buf & 0xffe0e002; */
+ 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);
+ break;
+
+ case 32:
+ new_val = apply_field_selector (val, 0, hppa_fixP->fx_r_field);
+ result = new_val; /* no transformation on result */
+ /* *(long *)buf = 0; *//* clear out everything */
+ bfd_put_32 (stdoutput, 0, buf); /* clear out everything */
+ 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;
+ long *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 == &bfd_abs_section
+ || seg == &bfd_und_section
+ || seg == text_section
+ || seg == data_section
+ || seg == bss_section
+ || seg == diff_section
+ || seg == big_section
+ || seg == absent_section))
+ {
+ 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;
+}
+
+int
+getAbsoluteExpression (str)
+ char *str;
+{
+ char *save_in;
+ asection *seg;
+
+ save_in = input_line_pointer;
+ input_line_pointer = str;
+ seg = expression (&the_insn.exp);
+
+ if (seg != &bfd_abs_section)
+ {
+ 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;
+}
+
+#else
+int
+getExpression (str)
+ char *str;
+{
+ char *save_in;
+ segT seg;
+
+ save_in = input_line_pointer;
+ input_line_pointer = str;
+ switch (seg = expression (&the_insn.exp))
+ {
+
+ case SEG_ABSOLUTE:
+ case SEG_TEXT:
+ case SEG_DATA:
+ case SEG_BSS:
+ case SEG_UNKNOWN:
+ case SEG_DIFFERENCE:
+ case SEG_BIG:
+ case SEG_GDB:
+ case SEG_MILLICODE:
+ case SEG_NONE:
+ break;
+
+ default:
+ 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;
+}
+
+int
+getAbsoluteExpression (str)
+ char *str;
+{
+ char *save_in;
+ segT seg;
+
+ save_in = input_line_pointer;
+ input_line_pointer = str;
+ switch (seg = expression (&the_insn.exp))
+ {
+
+ case SEG_ABSOLUTE:
+ break;
+
+ default:
+ 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;
+}
+
+#endif
+
+int
+evaluateAbsolute (exp, field_selector)
+ expressionS exp;
+ int field_selector;
+{
+ int value;
+
+ value = exp.X_add_number;
+
+ if (exp.X_add_symbol)
+ {
+ value += S_GET_VALUE (exp.X_add_symbol);
+ }
+ if (exp.X_subtract_symbol)
+ {
+ value -= S_GET_VALUE (exp.X_subtract_symbol);
+ }
+
+ 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;
+}
+
+#if 0
+int
+pa_parse_nonneg_cmpsub_cmpltr (s)
+ char **s;
+{
+ int cmpltr;
+ char *name;
+ char c;
+
+ cmpltr = -1;
+ /** cmpltr = 0; **/
+ if (**s == ',')
+ {
+ *s += 1;
+ 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 (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;
+ }
+ /**
+ else
+ cmpltr = -1;
+ **/
+ **s = c;
+ }
+ if (cmpltr >= 0)
+ {
+ while (**s == ' ' || **s == '\t')
+ *s = *s + 1;
+ }
+
+ return cmpltr;
+}
+
+#endif
+int
+pa_parse_nonneg_cmpsub_cmpltr (s)
+ char **s;
+{
+ int cmpltr;
+ char *name;
+ char c;
+
+ cmpltr = 0;
+ if (**s == ',')
+ {
+ *s += 1;
+ 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 (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;
+ }
+ else
+ cmpltr = -1;
+ **s = c;
+ }
+ if (cmpltr >= 0)
+ {
+ while (**s == ' ' || **s == '\t')
+ *s = *s + 1;
+ }
+
+ return cmpltr;
+}
+
+int
+pa_parse_neg_cmpsub_cmpltr (s)
+ char **s;
+{
+ int cmpltr;
+ char *name;
+ char c;
+
+ cmpltr = -1;
+ if (**s == ',')
+ {
+ *s += 1;
+ name = *s;
+ 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;
+ }
+ **s = c;
+ }
+ if (cmpltr >= 0)
+ {
+ while (**s == ' ' || **s == '\t')
+ *s = *s + 1;
+ }
+
+ return cmpltr;
+}
+
+int
+pa_parse_nonneg_add_cmpltr (s)
+ char **s;
+{
+ int cmpltr;
+ char *name;
+ char c;
+
+ cmpltr = -1;
+ if (**s == ',')
+ {
+ *s += 1;
+ 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;
+ }
+ **s = c;
+ }
+ if (cmpltr >= 0)
+ {
+ while (**s == ' ' || **s == '\t')
+ *s = *s + 1;
+ }
+
+ return cmpltr;
+}
+
+int
+pa_parse_neg_add_cmpltr (s)
+ char **s;
+{
+ int cmpltr;
+ char *name;
+ char c;
+
+ cmpltr = -1;
+ if (**s == ',')
+ {
+ *s += 1;
+ name = *s;
+ 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;
+ }
+ **s = c;
+ }
+ if (cmpltr >= 0)
+ {
+ while (**s == ' ' || **s == '\t')
+ *s = *s + 1;
+ }
+
+ return cmpltr;
+}
+
+void
+s_seg ()
+{
+
+ if (strncmp (input_line_pointer, "\"text\"", 6) == 0)
+ {
+ input_line_pointer += 6;
+ s_text ();
+ return;
+ }
+ if (strncmp (input_line_pointer, "\"data\"", 6) == 0)
+ {
+ input_line_pointer += 6;
+ s_data ();
+ 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 ();
+#ifdef OBJ_SOM
+ subseg_new (SEG_DATA, (subsegT) temp);
+#else
+ subseg_new (".data", (subsegT) temp);
+#endif
+ demand_empty_rest_of_line ();
+}
+
+void
+s_data1 ()
+{
+#ifdef OBJ_SOM
+ subseg_new (SEG_DATA, 1);
+#else
+ subseg_new (".data", 1);
+#endif
+ 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)
+ 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_ALLOC | 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_new ((char *) seg->name, 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, (symbolS *) NULL,
+ 0, 0, R_HPPA, 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, (symbolS *) NULL,
+ 0, 0, R_HPPA, 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_new ((char *) save_seg->name, 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_new (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, (symbolS *) NULL,
+ 0, 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, (symbolS *) NULL,
+ 0, 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_new (save_seg, save_subseg);
+
+}
+
+#endif
+#endif
+
+void
+pa_callinfo ()
+{
+ register char *name;
+ register char c;
+ register char *p;
+ register int temp;
+ register symbolS *symbolP;
+
+ 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;
+#ifdef OBJ_SOM
+
+ subseg_new (SEG_TEXT, SUBSEG_CODE);
+#else
+
+ subseg_new (".text", SUBSEG_CODE);
+#endif
+
+ 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 char *p;
+ register int size, i;
+ 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;
+ register char *p;
+ register int temp;
+ register symbolS *symbolP;
+
+ 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 *) index (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 (frag_now, where - frag_now->fr_literal, 0,
+ last_call_info->start_symbol, (symbolS *) NULL, 0, 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, (symbolS *) NULL, 0, 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 (frag_now, where - frag_now->fr_literal, 0,
+ last_call_info->start_symbol, (symbolS *) NULL, 0,
+ 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 = last_call_info->start_symbol->bsym->flags;
+ 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, (symbolS *) NULL, 0,
+ 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;
+}
+
+void
+pa_export ()
+{
+ register char *name;
+ register char c;
+ register char *p;
+ register int temp;
+ register int regno;
+ 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);
+ }
+ }
+
+ 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
+ elf_symbol_type *esymbolP = (elf_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;
+ register expressionS resultP; /* Deliver result here. */
+
+ 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 (); /* ORG actually allows another argument (the fill value)
+ but maybe this is OK? */
+ pa_undefine_label ();
+ 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)
+#ifdef OBJ_SOM
+ segT seg;
+#else
+ asection *seg;
+#endif
+ 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 char *p;
+ register int temp;
+ register symbolS *symbolP;
+ 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;
+#ifdef OBJ_SOM
+ if (now_seg != SEG_TEXT) /* no need to align if we are already there */
+#else
+ if (now_seg != text_section) /* no need to align if we are already there */
+#endif
+ pa_align_subseg (now_seg, now_subseg);
+
+#ifdef OBJ_SOM
+ subseg_new (SEG_TEXT, sd_chain->sd_last_subseg);
+ current_subspace = pa_subsegment_to_subspace (SEG_TEXT,
+ sd_chain->sd_last_subseg);
+#else
+ subseg_new ((char *) text_section->name, sd_chain->sd_last_subseg);
+ current_subspace = pa_subsegment_to_subspace (text_section,
+ sd_chain->sd_last_subseg);
+#endif
+ 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;
+#ifdef OBJ_SOM
+ if (now_seg != SEG_DATA) /* no need to align if we are already there */
+#else
+ if (now_seg != data_section) /* no need to align if we are already there */
+#endif
+ pa_align_subseg (now_seg, now_subseg);
+#ifdef OBJ_SOM
+ subseg_new (SEG_DATA, sd_chain->sd_last_subseg);
+ current_subspace = pa_subsegment_to_subspace (SEG_DATA,
+ sd_chain->sd_last_subseg);
+#else
+ subseg_new ((char *) data_section->name, sd_chain->sd_last_subseg);
+ current_subspace = pa_subsegment_to_subspace (data_section,
+ sd_chain->sd_last_subseg);
+#endif
+ 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_new (SEG_GDB, sd_chain->sd_last_subseg);
+ current_subspace = pa_subsegment_to_subspace (SEG_GDB,
+ sd_chain->sd_last_subseg);
+#else
+ if (now_seg != gdb_section) /* no need to align if we are already there */
+ pa_align_subseg (now_seg, now_subseg);
+ subseg_new ((char *) gdb_section->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);
+#ifdef OBJ_SOM
+ subseg_new (sd_chain->sd_seg, sd_chain->sd_last_subseg);
+#else
+ subseg_new ((char *) sd_chain->sd_seg->name, sd_chain->sd_last_subseg);
+#endif
+ 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);
+#ifdef OBJ_SOM
+ subseg_new (sd_chain->sd_seg, sd_chain->sd_last_subseg);
+#else
+ subseg_new ((char *) sd_chain->sd_seg->name, sd_chain->sd_last_subseg);
+#endif
+ 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 char *p;
+ register int temp;
+ register symbolS *symbolP;
+
+ char loadable, code_only, common, dup_common, zero;
+ char sort;
+ int number;
+ int i;
+ int access;
+ int space_index;
+ int alignment;
+ int quadrant;
+ int subseg;
+ space_dict_chainS *space;
+ subspace_dict_chainS *ssd;
+ subspace_dict_chainS *ssdCh;
+ 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_new (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 ();
+#ifdef OBJ_SOM
+ subseg_new (current_subspace->ssd_seg, current_subspace->ssd_subseg);
+#else
+ subseg_new ((char *) current_subspace->ssd_seg->name, current_subspace->ssd_subseg);
+#endif
+ }
+ 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_hook ()
+{
+ extern call_infoS *call_info_root;
+
+ call_infoS *ciP;
+
+ for (ciP = call_info_root; ciP; ciP = ciP->ci_next)
+ {
+ elf_symbol_type *esym = (elf_symbol_type *) ciP->start_symbol->bsym;
+ esym->internal_elf_sym.st_size =
+ ciP->end_symbol->bsym->value
+ - ciP->start_symbol->bsym->value + 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;
+
+extern symbolS *start_symbol_root;
+extern symbolS *start_symbol_last;
+
+void
+pa_spaces_begin ()
+{
+ space_dict_chainS *space;
+ int i;
+ subsegT now_subseg = now_subseg;
+
+ space_dict_root = NULL;
+ space_dict_last = NULL;
+
+ start_symbol_root = NULL;
+ start_symbol_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;
+ }
+ }
+ }
+ 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 ();
+ 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 ();
+ 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 ();
+ pa_undefine_label ();
+}
+
+void
+pa_big_cons (nbytes)
+ register int nbytes;
+{
+ big_cons (nbytes);
+ pa_undefine_label ();
+}
+
+void
+pa_text ()
+{
+ s_text ();
+ pa_undefine_label ();
+}
/* tc-i860.c -- Assemble for the I860
Copyright (C) 1989, 1992 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 2, 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. */
#include "opcode/i860.h"
-/* incorporated from i860.h */
-enum reloc_type /* NOTE: three bits max, see struct reloc_info_i860.r_type */
-{
- NO_RELOC = 0, BRADDR, LOW0, LOW1, LOW2, LOW3, LOW4, SPLIT0, SPLIT1, SPLIT2, RELOC_32,
-};
-
-enum highlow_type /* NOTE: two bits max, see reloc_info_i860.r_type */
-{
- NO_SPEC = 0, PAIR, HIGH, HIGHADJ,
-};
-
-struct reloc_info_i860
-{
- unsigned long r_address;
- /*
- * Using bit fields here is a bad idea because the order is not portable. :-(
- */
- unsigned int r_symbolnum: 24;
- unsigned int r_pcrel : 1;
- unsigned int r_extern : 1;
- /* combining the two field simplifies the argument passing in "new_fix()" */
- /* and is compatible with the existing Sparc #ifdef's */
- /* r_type: highlow_type - bits 5,4; reloc_type - bits 3-0 */
- unsigned int r_type : 6;
- long r_addend;
-};
-
-#define relocation_info reloc_info_i860
-
-
-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();
-static void i860_ip();
-void emit_machine_reloc();
+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 ();
+static void i860_ip ();
+/* void emit_machine_reloc(); */
-int md_reloc_size = sizeof(struct relocation_info);
+const int md_reloc_size = sizeof (struct relocation_info);
-void (*md_emit_relocations)() = emit_machine_reloc;
+/* void (*md_emit_relocations)() = emit_machine_reloc; */
-const relax_typeS md_relax_table[] = { 0 };
+const relax_typeS md_relax_table[] =
+{0};
/* handle of the OPCODE hash table */
static struct hash_control *op_hash = NULL;
-static void s_dual(), s_enddual();
-static void s_atmp();
+static void s_dual (), s_enddual ();
+static void s_atmp ();
const pseudo_typeS
- md_pseudo_table[] = {
- { "dual", s_dual, 4 },
- { "enddual", s_enddual, 4 },
- { "atmp", s_atmp, 4 },
- { NULL, 0, 0 },
- };
+ md_pseudo_table[] =
+{
+ {"dual", s_dual, 4},
+ {"enddual", s_enddual, 4},
+ {"atmp", s_atmp, 4},
+ {NULL, 0, 0},
+};
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 */
-char comment_chars[] = "!/"; /* JF removed '|' from comment_chars */
+const char comment_chars[] = "!/"; /* JF removed '|' from comment_chars */
/* 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'
first line of the input file. This is because the compiler outputs
#NO_APP at the beginning of its output. */
/* Also note that comments like this one will always work. */
-char line_comment_chars[] = "#/";
+const char line_comment_chars[] = "#/";
+
+const char line_separator_chars[] = "";
/* Chars that can be used to separate mant from exp in floating point nums */
-char EXP_CHARS[] = "eE";
+const char EXP_CHARS[] = "eE";
/* Chars that mean this number is a floating point constant */
/* As in 0f12.456 */
/* or 0d1.2345e12 */
-char FLT_CHARS[] = "rRsSfFdDxXpP";
+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.
*/
-int size_reloc_info = sizeof(struct relocation_info);
+int size_reloc_info = sizeof (struct relocation_info);
static unsigned char octal[256];
#define isoctal(c) octal[c]
- static unsigned char toHex[256];
-
-struct i860_it {
- char *error;
- unsigned long opcode;
- struct nlist *nlistp;
- expressionS exp;
- int pcrel;
- enum expand_type expand;
- enum highlow_type highlow;
- enum reloc_type reloc;
-} the_insn;
+static unsigned char toHex[256];
+
+struct i860_it
+ {
+ char *error;
+ unsigned long opcode;
+ struct nlist *nlistp;
+ expressionS exp;
+ int pcrel;
+ enum expand_type expand;
+ enum highlow_type highlow;
+ enum reloc_type reloc;
+ } the_insn;
#if __STDC__ == 1
-static void print_insn(struct i860_it *insn);
-static int getExpression(char *str);
+static void print_insn (struct i860_it *insn);
+static int getExpression (char *str);
#else /* not __STDC__ */
-static void print_insn();
-static int getExpression();
+static void print_insn ();
+static int getExpression ();
#endif /* not __STDC__ */
enum dual
{
- DUAL_OFF = 0, DUAL_ON, DUAL_DDOT, DUAL_ONDDOT,
+ DUAL_OFF = 0, DUAL_ON, DUAL_DDOT, DUAL_ONDDOT,
};
static enum dual dual_mode = DUAL_OFF; /* dual-instruction mode */
static void
- s_dual() /* floating point instructions have dual set */
+s_dual () /* floating point instructions have dual set */
{
- dual_mode = DUAL_ON;
+ dual_mode = DUAL_ON;
}
static void
- s_enddual() /* floating point instructions have dual set */
+s_enddual () /* floating point instructions have dual set */
{
- dual_mode = DUAL_OFF;
+ dual_mode = DUAL_OFF;
}
-static int atmp = 31; /* temporary register for pseudo's */
+static int atmp = 31; /* temporary register for pseudo's */
static void
- s_atmp()
+s_atmp ()
{
- register int temp;
- if (strncmp(input_line_pointer, "sp", 2) == 0) {
- input_line_pointer += 2;
- atmp = 2;
- }
- else if (strncmp(input_line_pointer, "fp", 2) == 0) {
- input_line_pointer += 2;
- atmp = 3;
- }
- else if (strncmp(input_line_pointer, "r", 1) == 0) {
- input_line_pointer += 1;
- temp = get_absolute_expression();
- if (temp >= 0 && temp <= 31)
- atmp = temp;
- else
- as_bad("Unknown temporary pseudo register");
- }
- else {
- as_bad("Unknown temporary pseudo register");
- }
- demand_empty_rest_of_line();
- return;
+ register int temp;
+ if (strncmp (input_line_pointer, "sp", 2) == 0)
+ {
+ input_line_pointer += 2;
+ atmp = 2;
+ }
+ else if (strncmp (input_line_pointer, "fp", 2) == 0)
+ {
+ input_line_pointer += 2;
+ atmp = 3;
+ }
+ else if (strncmp (input_line_pointer, "r", 1) == 0)
+ {
+ input_line_pointer += 1;
+ temp = get_absolute_expression ();
+ if (temp >= 0 && temp <= 31)
+ atmp = temp;
+ else
+ as_bad ("Unknown temporary pseudo register");
+ }
+ else
+ {
+ as_bad ("Unknown temporary pseudo register");
+ }
+ demand_empty_rest_of_line ();
+ return;
}
/* 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()
+md_begin ()
{
- register char *retval = NULL;
- int lose = 0;
- register unsigned int i = 0;
-
- op_hash = hash_new();
- if (op_hash == NULL)
- as_fatal("Virtual memory exhausted");
-
- while (i < NUMOPCODES)
+ register char *retval = NULL;
+ int lose = 0;
+ register unsigned int i = 0;
+
+ op_hash = hash_new ();
+ if (op_hash == NULL)
+ as_fatal ("Virtual memory exhausted");
+
+ while (i < NUMOPCODES)
+ {
+ const char *name = i860_opcodes[i].name;
+ retval = hash_insert (op_hash, name, &i860_opcodes[i]);
+ if (retval != NULL && *retval != '\0')
+ {
+ fprintf (stderr, "internal error: can't hash `%s': %s\n",
+ i860_opcodes[i].name, retval);
+ lose = 1;
+ }
+ do
+ {
+ if (i860_opcodes[i].match & i860_opcodes[i].lose)
{
- const char *name = i860_opcodes[i].name;
- retval = hash_insert(op_hash, name, &i860_opcodes[i]);
- if(retval != NULL && *retval != '\0')
- {
- fprintf (stderr, "internal error: can't hash `%s': %s\n",
- i860_opcodes[i].name, retval);
- lose = 1;
- }
- do
- {
- if (i860_opcodes[i].match & i860_opcodes[i].lose)
- {
- fprintf (stderr, "internal error: losing opcode: `%s' \"%s\"\n",
- i860_opcodes[i].name, i860_opcodes[i].args);
- lose = 1;
- }
- ++i;
- } while (i < NUMOPCODES
- && !strcmp(i860_opcodes[i].name, name));
+ fprintf (stderr, "internal error: losing opcode: `%s' \"%s\"\n",
+ i860_opcodes[i].name, i860_opcodes[i].args);
+ lose = 1;
}
-
- 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';
+ ++i;
+ }
+ while (i < NUMOPCODES
+ && !strcmp (i860_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()
+md_end ()
{
- return;
+ return;
}
void
- md_assemble(str)
-char *str;
+md_assemble (str)
+ char *str;
{
- char *toP;
- int rsd;
- int no_opcodes = 1;
- int i;
- struct i860_it pseudo[3];
-
- assert(str);
- i860_ip(str);
-
- /* check for expandable flag to produce pseudo-instructions */
- if (the_insn.expand != 0 && the_insn.highlow == NO_SPEC) {
- for (i = 0; i < 3; i++)
- pseudo[i] = the_insn;
-
- switch (the_insn.expand) {
-
- case E_DELAY:
- no_opcodes = 1;
- break;
-
- case E_MOV:
- if (the_insn.exp.X_add_symbol == NULL &&
- the_insn.exp.X_subtract_symbol == NULL &&
- (the_insn.exp.X_add_number < (1 << 15) &&
- the_insn.exp.X_add_number >= -(1 << 15)))
- break;
- /* or l%const,r0,ireg_dest */
- pseudo[0].opcode = (the_insn.opcode & 0x001f0000) | 0xe4000000;
- pseudo[0].highlow = PAIR;
- /* orh h%const,ireg_dest,ireg_dest */
- pseudo[1].opcode = (the_insn.opcode & 0x03ffffff) | 0xec000000 |
- ((the_insn.opcode & 0x001f0000) << 5);
- pseudo[1].highlow = HIGH;
- no_opcodes = 2;
- break;
-
- case E_ADDR:
- if (the_insn.exp.X_add_symbol == NULL &&
- the_insn.exp.X_subtract_symbol == NULL)
- break;
- /* orh ha%addr_expr,r0,r31 */
- pseudo[0].opcode = 0xec000000 | (atmp<<16);
- pseudo[0].highlow = HIGHADJ;
- pseudo[0].reloc = LOW0; /* must overwrite */
- /* l%addr_expr(r31),ireg_dest */
- pseudo[1].opcode = (the_insn.opcode & ~0x003e0000) | (atmp << 21);
- pseudo[1].highlow = PAIR;
- no_opcodes = 2;
- break;
-
- case E_U32: /* 2nd version emulates Intel as, not doc. */
- if (the_insn.exp.X_add_symbol == NULL &&
- the_insn.exp.X_subtract_symbol == NULL &&
- (the_insn.exp.X_add_number < (1 << 16) &&
- the_insn.exp.X_add_number >= 0))
- break;
- /* $(opcode)h h%const,ireg_src2,ireg_dest
+ char *toP;
+ int rsd;
+ int no_opcodes = 1;
+ int i;
+ struct i860_it pseudo[3];
+
+ assert (str);
+ i860_ip (str);
+
+ /* check for expandable flag to produce pseudo-instructions */
+ if (the_insn.expand != 0 && the_insn.highlow == NO_SPEC)
+ {
+ for (i = 0; i < 3; i++)
+ pseudo[i] = the_insn;
+
+ switch (the_insn.expand)
+ {
+
+ case E_DELAY:
+ no_opcodes = 1;
+ break;
+
+ case E_MOV:
+ if (the_insn.exp.X_add_symbol == NULL &&
+ the_insn.exp.X_subtract_symbol == NULL &&
+ (the_insn.exp.X_add_number < (1 << 15) &&
+ the_insn.exp.X_add_number >= -(1 << 15)))
+ break;
+ /* or l%const,r0,ireg_dest */
+ pseudo[0].opcode = (the_insn.opcode & 0x001f0000) | 0xe4000000;
+ pseudo[0].highlow = PAIR;
+ /* orh h%const,ireg_dest,ireg_dest */
+ pseudo[1].opcode = (the_insn.opcode & 0x03ffffff) | 0xec000000 |
+ ((the_insn.opcode & 0x001f0000) << 5);
+ pseudo[1].highlow = HIGH;
+ no_opcodes = 2;
+ break;
+
+ case E_ADDR:
+ if (the_insn.exp.X_add_symbol == NULL &&
+ the_insn.exp.X_subtract_symbol == NULL)
+ break;
+ /* orh ha%addr_expr,r0,r31 */
+ pseudo[0].opcode = 0xec000000 | (atmp << 16);
+ pseudo[0].highlow = HIGHADJ;
+ pseudo[0].reloc = LOW0; /* must overwrite */
+ /* l%addr_expr(r31),ireg_dest */
+ pseudo[1].opcode = (the_insn.opcode & ~0x003e0000) | (atmp << 21);
+ pseudo[1].highlow = PAIR;
+ no_opcodes = 2;
+ break;
+
+ case E_U32: /* 2nd version emulates Intel as, not doc. */
+ if (the_insn.exp.X_add_symbol == NULL &&
+ the_insn.exp.X_subtract_symbol == NULL &&
+ (the_insn.exp.X_add_number < (1 << 16) &&
+ the_insn.exp.X_add_number >= 0))
+ break;
+ /* $(opcode)h h%const,ireg_src2,ireg_dest
pseudo[0].opcode = (the_insn.opcode & 0xf3ffffff) | 0x0c000000; */
- /* $(opcode)h h%const,ireg_src2,r31 */
- pseudo[0].opcode = (the_insn.opcode & 0xf3e0ffff) | 0x0c000000 |
- (atmp << 16);
- pseudo[0].highlow = HIGH;
- /* $(opcode) l%const,ireg_dest,ireg_dest
+ /* $(opcode)h h%const,ireg_src2,r31 */
+ pseudo[0].opcode = (the_insn.opcode & 0xf3e0ffff) | 0x0c000000 |
+ (atmp << 16);
+ pseudo[0].highlow = HIGH;
+ /* $(opcode) l%const,ireg_dest,ireg_dest
pseudo[1].opcode = (the_insn.opcode & 0xf01f0000) | 0x04000000 |
((the_insn.opcode & 0x001f0000) << 5); */
- /* $(opcode) l%const,r31,ireg_dest */
- pseudo[1].opcode = (the_insn.opcode & 0xf01f0000) | 0x04000000 |
- (atmp << 21);
- pseudo[1].highlow = PAIR;
- no_opcodes = 2;
- break;
-
- case E_AND: /* 2nd version emulates Intel as, not doc. */
- if (the_insn.exp.X_add_symbol == NULL &&
- the_insn.exp.X_subtract_symbol == NULL &&
- (the_insn.exp.X_add_number < (1 << 16) &&
- the_insn.exp.X_add_number >= 0))
- break;
- /* andnot h%const,ireg_src2,ireg_dest
+ /* $(opcode) l%const,r31,ireg_dest */
+ pseudo[1].opcode = (the_insn.opcode & 0xf01f0000) | 0x04000000 |
+ (atmp << 21);
+ pseudo[1].highlow = PAIR;
+ no_opcodes = 2;
+ break;
+
+ case E_AND: /* 2nd version emulates Intel as, not doc. */
+ if (the_insn.exp.X_add_symbol == NULL &&
+ the_insn.exp.X_subtract_symbol == NULL &&
+ (the_insn.exp.X_add_number < (1 << 16) &&
+ the_insn.exp.X_add_number >= 0))
+ break;
+ /* andnot h%const,ireg_src2,ireg_dest
pseudo[0].opcode = (the_insn.opcode & 0x03ffffff) | 0xd4000000; */
- /* andnot h%const,ireg_src2,r31 */
- pseudo[0].opcode = (the_insn.opcode & 0x03e0ffff) | 0xd4000000 |
- (atmp << 16);
- pseudo[0].highlow = HIGH;
- pseudo[0].exp.X_add_number = -1 - the_insn.exp.X_add_number;
- /* andnot l%const,ireg_dest,ireg_dest
+ /* andnot h%const,ireg_src2,r31 */
+ pseudo[0].opcode = (the_insn.opcode & 0x03e0ffff) | 0xd4000000 |
+ (atmp << 16);
+ pseudo[0].highlow = HIGH;
+ pseudo[0].exp.X_add_number = -1 - the_insn.exp.X_add_number;
+ /* andnot l%const,ireg_dest,ireg_dest
pseudo[1].opcode = (the_insn.opcode & 0x001f0000) | 0xd4000000 |
((the_insn.opcode & 0x001f0000) << 5); */
- /* andnot l%const,r31,ireg_dest */
- pseudo[1].opcode = (the_insn.opcode & 0x001f0000) | 0xd4000000 |
- (atmp << 21);
- pseudo[1].highlow = PAIR;
- pseudo[1].exp.X_add_number = -1 - the_insn.exp.X_add_number;
- no_opcodes = 2;
- break;
-
- case E_S32:
- if (the_insn.exp.X_add_symbol == NULL &&
- the_insn.exp.X_subtract_symbol == NULL &&
- (the_insn.exp.X_add_number < (1 << 15) &&
- the_insn.exp.X_add_number >= -(1 << 15)))
- break;
- /* orh h%const,r0,r31 */
- pseudo[0].opcode = 0xec000000 | (atmp << 16);
- pseudo[0].highlow = HIGH;
- /* or l%const,r31,r31 */
- pseudo[1].opcode = 0xe4000000 | (atmp << 21) | (atmp << 16);
- pseudo[1].highlow = PAIR;
- /* r31,ireg_src2,ireg_dest */
- pseudo[2].opcode = (the_insn.opcode & ~0x0400ffff) | (atmp << 11);
- pseudo[2].reloc = NO_RELOC;
- no_opcodes = 3;
- break;
-
- default:
- as_fatal("failed sanity check.");
- }
-
- the_insn = pseudo[0];
- /* check for expanded opcode after branch or in dual */
- if (no_opcodes > 1 && last_expand == 1)
- as_warn("Expanded opcode after delayed branch: `%s'", str);
- if (no_opcodes > 1 && dual_mode != DUAL_OFF)
- as_warn("Expanded opcode in dual mode: `%s'", str);
+ /* andnot l%const,r31,ireg_dest */
+ pseudo[1].opcode = (the_insn.opcode & 0x001f0000) | 0xd4000000 |
+ (atmp << 21);
+ pseudo[1].highlow = PAIR;
+ pseudo[1].exp.X_add_number = -1 - the_insn.exp.X_add_number;
+ no_opcodes = 2;
+ break;
+
+ case E_S32:
+ if (the_insn.exp.X_add_symbol == NULL &&
+ the_insn.exp.X_subtract_symbol == NULL &&
+ (the_insn.exp.X_add_number < (1 << 15) &&
+ the_insn.exp.X_add_number >= -(1 << 15)))
+ break;
+ /* orh h%const,r0,r31 */
+ pseudo[0].opcode = 0xec000000 | (atmp << 16);
+ pseudo[0].highlow = HIGH;
+ /* or l%const,r31,r31 */
+ pseudo[1].opcode = 0xe4000000 | (atmp << 21) | (atmp << 16);
+ pseudo[1].highlow = PAIR;
+ /* r31,ireg_src2,ireg_dest */
+ pseudo[2].opcode = (the_insn.opcode & ~0x0400ffff) | (atmp << 11);
+ pseudo[2].reloc = NO_RELOC;
+ no_opcodes = 3;
+ break;
+
+ default:
+ as_fatal ("failed sanity check.");
}
-
- i = 0;
- do { /* always produce at least one opcode */
- toP = frag_more(4);
- /* put out the opcode */
- md_number_to_chars(toP, the_insn.opcode, 4);
-
- /* check for expanded opcode after branch or in dual */
- last_expand = the_insn.pcrel;
-
- /* put out the symbol-dependent stuff */
- if (the_insn.reloc != NO_RELOC) {
- fix_new(
- frag_now, /* which frag */
- (toP - frag_now->fr_literal), /* where */
- 4, /* size */
- the_insn.exp.X_add_symbol,
- the_insn.exp.X_subtract_symbol,
- the_insn.exp.X_add_number,
- the_insn.pcrel,
- /* merge bit fields into one argument */
- (int)(((the_insn.highlow & 0x3) << 4) | (the_insn.reloc & 0xf))
- );
- }
- the_insn = pseudo[++i];
- } while (--no_opcodes > 0);
-
+
+ the_insn = pseudo[0];
+ /* check for expanded opcode after branch or in dual */
+ if (no_opcodes > 1 && last_expand == 1)
+ as_warn ("Expanded opcode after delayed branch: `%s'", str);
+ if (no_opcodes > 1 && dual_mode != DUAL_OFF)
+ as_warn ("Expanded opcode in dual mode: `%s'", str);
+ }
+
+ i = 0;
+ do
+ { /* always produce at least one opcode */
+ toP = frag_more (4);
+ /* put out the opcode */
+ md_number_to_chars (toP, the_insn.opcode, 4);
+
+ /* check for expanded opcode after branch or in dual */
+ last_expand = the_insn.pcrel;
+
+ /* put out the symbol-dependent stuff */
+ if (the_insn.reloc != NO_RELOC)
+ {
+ fix_new (frag_now, /* which frag */
+ (toP - frag_now->fr_literal), /* where */
+ 4, /* size */
+ the_insn.exp.X_add_symbol,
+ the_insn.exp.X_subtract_symbol,
+ the_insn.exp.X_add_number,
+ the_insn.pcrel,
+ /* merge bit fields into one argument */
+ (int) (((the_insn.highlow & 0x3) << 4) | (the_insn.reloc & 0xf)));
+ }
+ the_insn = pseudo[++i];
+ }
+ while (--no_opcodes > 0);
+
}
static void
- i860_ip(str)
-char *str;
+i860_ip (str)
+ char *str;
{
- char *s;
- const char *args;
- char c;
- unsigned long i;
- struct i860_opcode *insn;
- char *argsStart;
- unsigned long opcode;
- unsigned int mask;
- int match = 0;
- int comma = 0;
-
-
- for (s = str; islower(*s) || *s == '.' || *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);
- }
-
- if (strncmp(str, "d.", 2) == 0) { /* check for d. opcode prefix */
- if (dual_mode == DUAL_ON)
- dual_mode = DUAL_ONDDOT;
- else
- dual_mode = DUAL_DDOT;
- str += 2;
- }
-
- if ((insn = (struct i860_opcode *) hash_find(op_hash, str)) == NULL) {
- if (dual_mode == DUAL_DDOT || dual_mode == DUAL_ONDDOT)
- str -= 2;
- as_bad("Unknown opcode: `%s'", str);
- return;
- }
- if (comma) {
- *--s = ',';
- }
- argsStart = s;
- for (;;) {
- opcode = insn->match;
- memset(&the_insn, '\0', sizeof(the_insn));
- the_insn.reloc = NO_RELOC;
-
- /*
+ char *s;
+ const char *args;
+ char c;
+ unsigned long i;
+ struct i860_opcode *insn;
+ char *argsStart;
+ unsigned long opcode;
+ unsigned int mask;
+ int match = 0;
+ int comma = 0;
+
+
+ for (s = str; islower (*s) || *s == '.' || *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);
+ }
+
+ if (strncmp (str, "d.", 2) == 0)
+ { /* check for d. opcode prefix */
+ if (dual_mode == DUAL_ON)
+ dual_mode = DUAL_ONDDOT;
+ else
+ dual_mode = DUAL_DDOT;
+ str += 2;
+ }
+
+ if ((insn = (struct i860_opcode *) hash_find (op_hash, str)) == NULL)
+ {
+ if (dual_mode == DUAL_DDOT || dual_mode == DUAL_ONDDOT)
+ str -= 2;
+ as_bad ("Unknown opcode: `%s'", str);
+ return;
+ }
+ if (comma)
+ {
+ *--s = ',';
+ }
+ argsStart = s;
+ for (;;)
+ {
+ opcode = insn->match;
+ memset (&the_insn, '\0', sizeof (the_insn));
+ the_insn.reloc = NO_RELOC;
+
+ /*
* 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 = 1;
- }
- break;
-
- case '+':
- case '(': /* these must match exactly */
- case ')':
- case ',':
- case ' ':
- if (*s++ == *args)
- continue;
- break;
-
- case '#': /* must be at least one digit */
- if (isdigit(*s++)) {
- while (isdigit(*s)) {
- ++s;
- }
- continue;
- }
- break;
-
- case '1': /* next operand must be a register */
- case '2':
- case 'd':
- switch (*s) {
-
- case 'f': /* frame pointer */
- s++;
- if (*s++ == 'p') {
- mask = 0x3;
- break;
- }
- goto error;
-
- case 's': /* stack pointer */
- s++;
- if (*s++ == 'p') {
- mask= 0x2;
- break;
- }
- goto error;
-
- case 'r': /* any register */
- s++;
- if (!isdigit(c = *s++)) {
- goto error;
- }
- if (isdigit(*s)) {
- if ((c = 10 * (c - '0') + (*s++ - '0')) >= 32) {
- goto error;
- }
- } else {
- c -= '0';
- }
- mask= c;
- break;
-
- default: /* not this opcode */
- goto error;
- }
- /*
+ for (args = insn->args;; ++args)
+ {
+ switch (*args)
+ {
+
+ case '\0': /* end of args */
+ if (*s == '\0')
+ {
+ match = 1;
+ }
+ break;
+
+ case '+':
+ case '(': /* these must match exactly */
+ case ')':
+ case ',':
+ case ' ':
+ if (*s++ == *args)
+ continue;
+ break;
+
+ case '#': /* must be at least one digit */
+ if (isdigit (*s++))
+ {
+ while (isdigit (*s))
+ {
+ ++s;
+ }
+ continue;
+ }
+ break;
+
+ case '1': /* next operand must be a register */
+ case '2':
+ case 'd':
+ switch (*s)
+ {
+
+ case 'f': /* frame pointer */
+ s++;
+ if (*s++ == 'p')
+ {
+ mask = 0x3;
+ break;
+ }
+ goto error;
+
+ case 's': /* stack pointer */
+ s++;
+ if (*s++ == 'p')
+ {
+ mask = 0x2;
+ break;
+ }
+ goto error;
+
+ case 'r': /* any register */
+ s++;
+ if (!isdigit (c = *s++))
+ {
+ goto error;
+ }
+ if (isdigit (*s))
+ {
+ if ((c = 10 * (c - '0') + (*s++ - '0')) >= 32)
+ {
+ goto error;
+ }
+ }
+ else
+ {
+ c -= '0';
+ }
+ mask = c;
+ break;
+
+ default: /* not this opcode */
+ goto error;
+ }
+ /*
* Got the register, now figure out where
* it goes in the opcode.
*/
- switch (*args) {
-
- case '1':
- opcode |= mask << 11;
- continue;
-
- case '2':
- opcode |= mask << 21;
- continue;
-
- case 'd':
- opcode |= mask << 16;
- continue;
-
- }
- break;
-
- case 'e': /* next operand is a floating point register */
- case 'f':
- case 'g':
- if (*s++ == 'f' && isdigit(*s)) {
- mask = *s++;
- if (isdigit(*s)) {
- mask = 10 * (mask - '0') + (*s++ - '0');
- if (mask >= 32) {
- break;
- }
- } else {
- mask -= '0';
- }
- switch (*args) {
-
- case 'e':
- opcode |= mask << 11;
- continue;
-
- case 'f':
- opcode |= mask << 21;
- continue;
-
- case 'g':
- opcode |= mask << 16;
- if (dual_mode != DUAL_OFF)
- opcode |= (1 << 9); /* dual mode instruction */
- if (dual_mode == DUAL_DDOT)
- dual_mode = DUAL_OFF;
- if (dual_mode == DUAL_ONDDOT)
- dual_mode = DUAL_ON;
- if ((opcode & (1 << 10)) && (mask == ((opcode >> 11) & 0x1f)))
- as_warn("Fsr1 equals fdest with Pipelining");
- continue;
- }
- }
- break;
-
- case 'c': /* next operand must be a control register */
- if (strncmp(s, "fir", 3) == 0) {
- opcode |= 0x0 << 21;
- s += 3;
- continue;
- }
- if (strncmp(s, "psr", 3) == 0) {
- opcode |= 0x1 << 21;
- s += 3;
- continue;
- }
- if (strncmp(s, "dirbase", 7) == 0) {
- opcode |= 0x2 << 21;
- s += 7;
- continue;
- }
- if (strncmp(s, "db", 2) == 0) {
- opcode |= 0x3 << 21;
- s += 2;
- continue;
- }
- if (strncmp(s, "fsr", 3) == 0) {
- opcode |= 0x4 << 21;
- s += 3;
- continue;
- }
- if (strncmp(s, "epsr", 4) == 0) {
- opcode |= 0x5 << 21;
- s += 4;
- continue;
- }
- break;
-
- case '5': /* 5 bit immediate in src1 */
- memset(&the_insn, '\0', sizeof(the_insn));
- if ( !getExpression(s)) {
- s = expr_end;
- if (the_insn.exp.X_add_number & ~0x1f)
- as_bad("5-bit immediate too large");
- opcode |= (the_insn.exp.X_add_number & 0x1f) << 11;
- memset(&the_insn, '\0', sizeof(the_insn));
- the_insn.reloc = NO_RELOC;
- continue;
- }
- break;
-
- case 'l': /* 26 bit immediate, relative branch */
- the_insn.reloc = BRADDR;
- the_insn.pcrel = 1;
- goto immediate;
-
- case 's': /* 16 bit immediate, split relative branch */
- /* upper 5 bits of offset in dest field */
- the_insn.pcrel = 1;
- the_insn.reloc = SPLIT0;
- goto immediate;
-
- case 'S': /* 16 bit immediate, split (st), aligned */
- if (opcode & (1 << 28))
- if (opcode & 0x1)
- the_insn.reloc = SPLIT2;
- else
- the_insn.reloc = SPLIT1;
- else
- the_insn.reloc = SPLIT0;
- goto immediate;
-
- case 'I': /* 16 bit immediate, aligned */
- if (opcode & (1 << 28))
- if (opcode & 0x1)
- the_insn.reloc = LOW2;
- else
- the_insn.reloc = LOW1;
- else
- the_insn.reloc = LOW0;
- goto immediate;
-
- case 'i': /* 16 bit immediate */
- the_insn.reloc = LOW0;
-
- /*FALLTHROUGH*/
-
- immediate:
- if(*s==' ')
- s++;
- if (strncmp(s, "ha%", 3) == 0) {
- the_insn.highlow = HIGHADJ;
- s += 3;
- } else if (strncmp(s, "h%", 2) == 0) {
- the_insn.highlow = HIGH;
- s += 2;
- } else if (strncmp(s, "l%", 2) == 0) {
- the_insn.highlow = PAIR;
- s += 2;
- }
- the_insn.expand = insn->expand;
-
- /* Note that if the getExpression() fails, we will still have
+ switch (*args)
+ {
+
+ case '1':
+ opcode |= mask << 11;
+ continue;
+
+ case '2':
+ opcode |= mask << 21;
+ continue;
+
+ case 'd':
+ opcode |= mask << 16;
+ continue;
+
+ }
+ break;
+
+ case 'e': /* next operand is a floating point register */
+ case 'f':
+ case 'g':
+ if (*s++ == 'f' && isdigit (*s))
+ {
+ mask = *s++;
+ if (isdigit (*s))
+ {
+ mask = 10 * (mask - '0') + (*s++ - '0');
+ if (mask >= 32)
+ {
+ break;
+ }
+ }
+ else
+ {
+ mask -= '0';
+ }
+ switch (*args)
+ {
+
+ case 'e':
+ opcode |= mask << 11;
+ continue;
+
+ case 'f':
+ opcode |= mask << 21;
+ continue;
+
+ case 'g':
+ opcode |= mask << 16;
+ if (dual_mode != DUAL_OFF)
+ opcode |= (1 << 9); /* dual mode instruction */
+ if (dual_mode == DUAL_DDOT)
+ dual_mode = DUAL_OFF;
+ if (dual_mode == DUAL_ONDDOT)
+ dual_mode = DUAL_ON;
+ if ((opcode & (1 << 10)) && (mask == ((opcode >> 11) & 0x1f)))
+ as_warn ("Fsr1 equals fdest with Pipelining");
+ continue;
+ }
+ }
+ break;
+
+ case 'c': /* next operand must be a control register */
+ if (strncmp (s, "fir", 3) == 0)
+ {
+ opcode |= 0x0 << 21;
+ s += 3;
+ continue;
+ }
+ if (strncmp (s, "psr", 3) == 0)
+ {
+ opcode |= 0x1 << 21;
+ s += 3;
+ continue;
+ }
+ if (strncmp (s, "dirbase", 7) == 0)
+ {
+ opcode |= 0x2 << 21;
+ s += 7;
+ continue;
+ }
+ if (strncmp (s, "db", 2) == 0)
+ {
+ opcode |= 0x3 << 21;
+ s += 2;
+ continue;
+ }
+ if (strncmp (s, "fsr", 3) == 0)
+ {
+ opcode |= 0x4 << 21;
+ s += 3;
+ continue;
+ }
+ if (strncmp (s, "epsr", 4) == 0)
+ {
+ opcode |= 0x5 << 21;
+ s += 4;
+ continue;
+ }
+ break;
+
+ case '5': /* 5 bit immediate in src1 */
+ memset (&the_insn, '\0', sizeof (the_insn));
+ if (!getExpression (s))
+ {
+ s = expr_end;
+ if (the_insn.exp.X_add_number & ~0x1f)
+ as_bad ("5-bit immediate too large");
+ opcode |= (the_insn.exp.X_add_number & 0x1f) << 11;
+ memset (&the_insn, '\0', sizeof (the_insn));
+ the_insn.reloc = NO_RELOC;
+ continue;
+ }
+ break;
+
+ case 'l': /* 26 bit immediate, relative branch */
+ the_insn.reloc = BRADDR;
+ the_insn.pcrel = 1;
+ goto immediate;
+
+ case 's': /* 16 bit immediate, split relative branch */
+ /* upper 5 bits of offset in dest field */
+ the_insn.pcrel = 1;
+ the_insn.reloc = SPLIT0;
+ goto immediate;
+
+ case 'S': /* 16 bit immediate, split (st), aligned */
+ if (opcode & (1 << 28))
+ if (opcode & 0x1)
+ the_insn.reloc = SPLIT2;
+ else
+ the_insn.reloc = SPLIT1;
+ else
+ the_insn.reloc = SPLIT0;
+ goto immediate;
+
+ case 'I': /* 16 bit immediate, aligned */
+ if (opcode & (1 << 28))
+ if (opcode & 0x1)
+ the_insn.reloc = LOW2;
+ else
+ the_insn.reloc = LOW1;
+ else
+ the_insn.reloc = LOW0;
+ goto immediate;
+
+ case 'i': /* 16 bit immediate */
+ the_insn.reloc = LOW0;
+
+ /*FALLTHROUGH*/
+
+ immediate:
+ if (*s == ' ')
+ s++;
+ if (strncmp (s, "ha%", 3) == 0)
+ {
+ the_insn.highlow = HIGHADJ;
+ s += 3;
+ }
+ else if (strncmp (s, "h%", 2) == 0)
+ {
+ the_insn.highlow = HIGH;
+ s += 2;
+ }
+ else if (strncmp (s, "l%", 2) == 0)
+ {
+ the_insn.highlow = PAIR;
+ s += 2;
+ }
+ the_insn.expand = insn->expand;
+
+ /* Note that if the getExpression() fails, we will still have
created U entries in the symbol table for the 'symbols'
in the input string. Try not to create U symbols for
registers, etc. */
-
- if ( !getExpression(s)) {
- s = expr_end;
- continue;
- }
- break;
-
- default:
- as_fatal("failed sanity check.");
- }
- break;
+
+ if (!getExpression (s))
+ {
+ s = expr_end;
+ continue;
}
- error:
- if (match == 0)
- {
- /* Args don't match. */
- if (&insn[1] - i860_opcodes < NUMOPCODES
- && !strcmp(insn->name, insn[1].name))
- {
- ++insn;
- s = argsStart;
- continue;
- }
- else
- {
- as_bad("Illegal operands");
- return;
- }
- }
- break;
+ break;
+
+ default:
+ as_fatal ("failed sanity check.");
+ }
+ break;
}
-
- the_insn.opcode = opcode;
- return;
+ error:
+ if (match == 0)
+ {
+ /* Args don't match. */
+ if (&insn[1] - i860_opcodes < NUMOPCODES
+ && !strcmp (insn->name, insn[1].name))
+ {
+ ++insn;
+ s = argsStart;
+ continue;
+ }
+ else
+ {
+ as_bad ("Illegal operands");
+ return;
+ }
+ }
+ break;
+ }
+
+ the_insn.opcode = opcode;
+ return;
}
static int
- getExpression(str)
-char *str;
+getExpression (str)
+ char *str;
{
- char *save_in;
- segT seg;
-
- save_in = input_line_pointer;
- input_line_pointer = str;
- switch (seg = expression(&the_insn.exp)) {
-
- case SEG_ABSOLUTE:
- case SEG_TEXT:
- case SEG_DATA:
- case SEG_BSS:
- case SEG_UNKNOWN:
- case SEG_DIFFERENCE:
- case SEG_BIG:
- case SEG_ABSENT:
- break;
-
- default:
- 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;
+ char *save_in;
+ segT seg;
+
+ save_in = input_line_pointer;
+ input_line_pointer = str;
+ switch (seg = expression (&the_insn.exp))
+ {
+
+ case SEG_ABSOLUTE:
+ case SEG_TEXT:
+ case SEG_DATA:
+ case SEG_BSS:
+ case SEG_UNKNOWN:
+ case SEG_DIFFERENCE:
+ case SEG_BIG:
+ case SEG_ABSENT:
+ break;
+
+ default:
+ 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;
}
/*
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.
#define MAX_LITTLENUMS 6
char *
- md_atof(type,litP,sizeP)
-char type;
-char *litP;
-int *sizeP;
+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 */
+ 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;
-long val;
-int n;
+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:
- as_fatal("failed sanity check.");
- }
- return;
+ switch (n)
+ {
+
+ case 4:
+ *buf++ = val >> 24;
+ *buf++ = val >> 16;
+ case 2:
+ *buf++ = val >> 8;
+ case 1:
+ *buf = val;
+ break;
+
+ default:
+ as_fatal ("failed sanity check.");
+ }
+ return;
}
-void md_number_to_imm(buf,val,n, fixP)
-char *buf;
-long val;
-int n;
-fixS *fixP;
+void
+md_number_to_imm (buf, val, n, fixP)
+ char *buf;
+ long val;
+ int n;
+ fixS *fixP;
{
- enum reloc_type reloc = fixP->fx_r_type & 0xf;
- enum highlow_type highlow = (fixP->fx_r_type >> 4) & 0x3;
-
- assert(buf);
- assert(n == 4); /* always on i860 */
-
- switch(highlow)
- {
-
- case HIGHADJ: /* adjusts the high-order 16-bits */
- if (val & (1 << 15))
- val += (1 << 16);
-
- /*FALLTHROUGH*/
-
- case HIGH: /* selects the high-order 16-bits */
- val >>= 16;
- break;
-
- case PAIR: /* selects the low-order 16-bits */
- val = val & 0xffff;
- break;
-
- default:
- break;
- }
-
- switch(reloc)
- {
-
- case BRADDR: /* br,call,bc,bc.t,bnc,bnc.t w/26-bit immediate */
- if (fixP->fx_pcrel != 1)
- as_bad("26-bit branch w/o pc relative set: 0x%08x", val);
- val >>= 2; /* align pcrel offset, see manual */
-
- if (val >= (1 << 25) || val < -(1 << 25)) /* check for overflow */
- as_bad("26-bit branch offset overflow: 0x%08x", val);
- buf[0] = (buf[0] & 0xfc) | ((val >> 24) & 0x3);
- buf[1] = val >> 16;
- buf[2] = val >> 8;
- buf[3] = val;
- break;
-
- case SPLIT2: /* 16 bit immediate, 4-byte aligned */
- if (val & 0x3)
- as_bad("16-bit immediate 4-byte alignment error: 0x%08x", val);
- val &= ~0x3; /* 4-byte align value */
- /*FALLTHROUGH*/
- case SPLIT1: /* 16 bit immediate, 2-byte aligned */
- if (val & 0x1)
- as_bad("16-bit immediate 2-byte alignment error: 0x%08x", val);
- val &= ~0x1; /* 2-byte align value */
- /*FALLTHROUGH*/
- case SPLIT0: /* st,bla,bte,btne w/16-bit immediate */
- if (fixP->fx_pcrel == 1)
- val >>= 2; /* align pcrel offset, see manual */
- /* check for bounds */
- if (highlow != PAIR && (val >= (1 << 16) || val < -(1 << 15)))
- as_bad("16-bit branch offset overflow: 0x%08x", val);
- buf[1] = (buf[1] & ~0x1f) | ((val >> 11) & 0x1f);
- buf[2] = (buf[2] & ~0x7) | ((val >> 8) & 0x7);
- buf[3] |= val; /* perserve bottom opcode bits */
- break;
-
- case LOW4: /* fld,pfld,pst,flush 16-byte aligned */
- if (val & 0xf)
- as_bad("16-bit immediate 16-byte alignment error: 0x%08x", val);
- val &= ~0xf; /* 16-byte align value */
- /*FALLTHROUGH*/
- case LOW3: /* fld,pfld,pst,flush 8-byte aligned */
- if (val & 0x7)
- as_bad("16-bit immediate 8-byte alignment error: 0x%08x", val);
- val &= ~0x7; /* 8-byte align value */
- /*FALLTHROUGH*/
- case LOW2: /* 16 bit immediate, 4-byte aligned */
- if (val & 0x3)
- as_bad("16-bit immediate 4-byte alignment error: 0x%08x", val);
- val &= ~0x3; /* 4-byte align value */
- /*FALLTHROUGH*/
- case LOW1: /* 16 bit immediate, 2-byte aligned */
- if (val & 0x1)
- as_bad("16-bit immediate 2-byte alignment error: 0x%08x", val);
- val &= ~0x1; /* 2-byte align value */
- /*FALLTHROUGH*/
- case LOW0: /* 16 bit immediate, byte aligned */
- /* check for bounds */
- if (highlow != PAIR && (val >= (1 << 16) || val < -(1 << 15)))
- as_bad("16-bit immediate overflow: 0x%08x", val);
- buf[2] = val >> 8;
- buf[3] |= val; /* perserve bottom opcode bits */
- break;
-
- case NO_RELOC:
- default:
- as_bad("bad relocation type: 0x%02x", reloc);
- break;
- }
- return;
+ enum reloc_type reloc = fixP->fx_r_type & 0xf;
+ enum highlow_type highlow = (fixP->fx_r_type >> 4) & 0x3;
+
+ assert (buf);
+ assert (n == 4); /* always on i860 */
+
+ switch (highlow)
+ {
+
+ case HIGHADJ: /* adjusts the high-order 16-bits */
+ if (val & (1 << 15))
+ val += (1 << 16);
+
+ /*FALLTHROUGH*/
+
+ case HIGH: /* selects the high-order 16-bits */
+ val >>= 16;
+ break;
+
+ case PAIR: /* selects the low-order 16-bits */
+ val = val & 0xffff;
+ break;
+
+ default:
+ break;
+ }
+
+ switch (reloc)
+ {
+
+ case BRADDR: /* br,call,bc,bc.t,bnc,bnc.t w/26-bit immediate */
+ if (fixP->fx_pcrel != 1)
+ as_bad ("26-bit branch w/o pc relative set: 0x%08x", val);
+ val >>= 2; /* align pcrel offset, see manual */
+
+ if (val >= (1 << 25) || val < -(1 << 25)) /* check for overflow */
+ as_bad ("26-bit branch offset overflow: 0x%08x", val);
+ buf[0] = (buf[0] & 0xfc) | ((val >> 24) & 0x3);
+ buf[1] = val >> 16;
+ buf[2] = val >> 8;
+ buf[3] = val;
+ break;
+
+ case SPLIT2: /* 16 bit immediate, 4-byte aligned */
+ if (val & 0x3)
+ as_bad ("16-bit immediate 4-byte alignment error: 0x%08x", val);
+ val &= ~0x3; /* 4-byte align value */
+ /*FALLTHROUGH*/
+ case SPLIT1: /* 16 bit immediate, 2-byte aligned */
+ if (val & 0x1)
+ as_bad ("16-bit immediate 2-byte alignment error: 0x%08x", val);
+ val &= ~0x1; /* 2-byte align value */
+ /*FALLTHROUGH*/
+ case SPLIT0: /* st,bla,bte,btne w/16-bit immediate */
+ if (fixP->fx_pcrel == 1)
+ val >>= 2; /* align pcrel offset, see manual */
+ /* check for bounds */
+ if (highlow != PAIR && (val >= (1 << 16) || val < -(1 << 15)))
+ as_bad ("16-bit branch offset overflow: 0x%08x", val);
+ buf[1] = (buf[1] & ~0x1f) | ((val >> 11) & 0x1f);
+ buf[2] = (buf[2] & ~0x7) | ((val >> 8) & 0x7);
+ buf[3] |= val; /* perserve bottom opcode bits */
+ break;
+
+ case LOW4: /* fld,pfld,pst,flush 16-byte aligned */
+ if (val & 0xf)
+ as_bad ("16-bit immediate 16-byte alignment error: 0x%08x", val);
+ val &= ~0xf; /* 16-byte align value */
+ /*FALLTHROUGH*/
+ case LOW3: /* fld,pfld,pst,flush 8-byte aligned */
+ if (val & 0x7)
+ as_bad ("16-bit immediate 8-byte alignment error: 0x%08x", val);
+ val &= ~0x7; /* 8-byte align value */
+ /*FALLTHROUGH*/
+ case LOW2: /* 16 bit immediate, 4-byte aligned */
+ if (val & 0x3)
+ as_bad ("16-bit immediate 4-byte alignment error: 0x%08x", val);
+ val &= ~0x3; /* 4-byte align value */
+ /*FALLTHROUGH*/
+ case LOW1: /* 16 bit immediate, 2-byte aligned */
+ if (val & 0x1)
+ as_bad ("16-bit immediate 2-byte alignment error: 0x%08x", val);
+ val &= ~0x1; /* 2-byte align value */
+ /*FALLTHROUGH*/
+ case LOW0: /* 16 bit immediate, byte aligned */
+ /* check for bounds */
+ if (highlow != PAIR && (val >= (1 << 16) || val < -(1 << 15)))
+ as_bad ("16-bit immediate overflow: 0x%08x", val);
+ buf[2] = val >> 8;
+ buf[3] |= val; /* perserve bottom opcode bits */
+ break;
+
+ case NO_RELOC:
+ default:
+ as_bad ("bad relocation type: 0x%02x", reloc);
+ break;
+ }
+ return;
}
/* should never be called for i860 */
void
- md_create_short_jump(ptr, from_addr, to_addr, frag, to_symbol)
-char *ptr;
-long from_addr, to_addr;
-fragS *frag;
-symbolS *to_symbol;
+md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
+ char *ptr;
+ addressT from_addr, to_addr;
+ fragS *frag;
+ symbolS *to_symbol;
{
- as_fatal("i860_create_short_jmp\n");
+ as_fatal ("i860_create_short_jmp\n");
}
/* should never be called for i860 */
void
- md_number_to_disp(buf,val,n)
-char *buf;
-long val;
+md_number_to_disp (buf, val, n)
+ char *buf;
+ long val;
{
- as_fatal("md_number_to_disp\n");
+ as_fatal ("md_number_to_disp\n");
}
/* should never be called for i860 */
void
- md_number_to_field(buf,val,fix)
-char *buf;
-long val;
-void *fix;
+md_number_to_field (buf, val, fix)
+ char *buf;
+ long val;
+ void *fix;
{
- as_fatal("i860_number_to_field\n");
+ as_fatal ("i860_number_to_field\n");
}
-/* the bit-field entries in the relocation_info struct plays hell
+/* 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 */
relocation type (highlow 5-4). Next 4 bytes are long addend. */
/* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com */
void
- md_ri_to_chars(ri_p, ri)
-struct relocation_info *ri_p, ri;
+md_ri_to_chars (ri_p, ri)
+ struct relocation_info *ri_p, ri;
{
#if 0
- unsigned char the_bytes[sizeof(*ri_p)];
-
- /* this is easy */
- md_number_to_chars(the_bytes, ri.r_address, sizeof(ri.r_address));
- /* now the fun stuff */
- the_bytes[4] = (ri.r_index >> 16) & 0x0ff;
- the_bytes[5] = (ri.r_index >> 8) & 0x0ff;
- the_bytes[6] = ri.r_index & 0x0ff;
- the_bytes[7] = ((ri.r_extern << 7) & 0x80) | (0 & 0x60) | (ri.r_type & 0x1F);
- /* Also easy */
- md_number_to_chars(&the_bytes[8], ri.r_addend, sizeof(ri.r_addend));
- /* now put it back where you found it, Junior... */
- memcpy((char *) ri_p, the_bytes, sizeof(*ri_p));
+ unsigned char the_bytes[sizeof (*ri_p)];
+
+ /* this is easy */
+ md_number_to_chars (the_bytes, ri.r_address, sizeof (ri.r_address));
+ /* now the fun stuff */
+ the_bytes[4] = (ri.r_index >> 16) & 0x0ff;
+ the_bytes[5] = (ri.r_index >> 8) & 0x0ff;
+ the_bytes[6] = ri.r_index & 0x0ff;
+ the_bytes[7] = ((ri.r_extern << 7) & 0x80) | (0 & 0x60) | (ri.r_type & 0x1F);
+ /* Also easy */
+ md_number_to_chars (&the_bytes[8], ri.r_addend, sizeof (ri.r_addend));
+ /* now put it back where you found it, Junior... */
+ memcpy ((char *) ri_p, the_bytes, sizeof (*ri_p));
#endif
}
/* should never be called for i860 */
void
- md_convert_frag(headers, fragP)
-object_headers *headers;
-register fragS *fragP;
+md_convert_frag (headers, fragP)
+ object_headers *headers;
+ register fragS *fragP;
{
- as_fatal("i860_convert_frag\n");
+ as_fatal ("i860_convert_frag\n");
}
/* should never be called for i860 */
void
- md_create_long_jump(ptr, from_addr, to_addr, frag, to_symbol)
-char *ptr;
-long from_addr,
- to_addr;
-fragS *frag;
-symbolS *to_symbol;
+md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
+ char *ptr;
+ addressT from_addr, to_addr;
+ fragS *frag;
+ symbolS *to_symbol;
{
- as_fatal("i860_create_long_jump\n");
+ as_fatal ("i860_create_long_jump\n");
}
/* should never be called for i860 */
int
- md_estimate_size_before_relax(fragP, segtype)
-register fragS *fragP;
-segT segtype;
+md_estimate_size_before_relax (fragP, segtype)
+ register fragS *fragP;
+ segT segtype;
{
- as_fatal("i860_estimate_size_before_relax\n");
+ as_fatal ("i860_estimate_size_before_relax\n");
}
/* for debugging only, must match enum reloc_type */
-static char *Reloc[] = {
- "NO_RELOC",
- "BRADDR",
- "LOW0",
- "LOW1",
- "LOW2",
- "LOW3",
- "LOW4",
- "SPLIT0",
- "SPLIT1",
- "SPLIT2",
- "RELOC_32",
+static char *Reloc[] =
+{
+ "NO_RELOC",
+ "BRADDR",
+ "LOW0",
+ "LOW1",
+ "LOW2",
+ "LOW3",
+ "LOW4",
+ "SPLIT0",
+ "SPLIT1",
+ "SPLIT2",
+ "RELOC_32",
};
-static char *Highlow[] = {
- "NO_SPEC",
- "PAIR",
- "HIGH",
- "HIGHADJ",
+static char *Highlow[] =
+{
+ "NO_SPEC",
+ "PAIR",
+ "HIGH",
+ "HIGHADJ",
};
static void
- print_insn(insn)
-struct i860_it *insn;
+print_insn (insn)
+ struct i860_it *insn;
{
- if (insn->error) {
- fprintf(stderr, "ERROR: %s\n");
- }
- fprintf(stderr, "opcode=0x%08x\t", insn->opcode);
- fprintf(stderr, "expand=0x%08x\t", insn->expand);
- fprintf(stderr, "reloc = %s\t", Reloc[insn->reloc]);
- fprintf(stderr, "highlow = %s\n", Highlow[insn->highlow]);
- fprintf(stderr, "exp = {\n");
- fprintf(stderr, "\t\tX_add_symbol = %s\n",
- insn->exp.X_add_symbol ?
- (S_GET_NAME(insn->exp.X_add_symbol) ?
- S_GET_NAME(insn->exp.X_add_symbol) : "???") : "0");
- fprintf(stderr, "\t\tX_sub_symbol = %s\n",
- insn->exp.X_subtract_symbol ?
- (S_GET_NAME(insn->exp.X_subtract_symbol) ?
- S_GET_NAME(insn->exp.X_subtract_symbol) : "???") : "0");
- fprintf(stderr, "\t\tX_add_number = %d\n",
- insn->exp.X_add_number);
- fprintf(stderr, "}\n");
- return;
+ if (insn->error)
+ {
+ fprintf (stderr, "ERROR: %s\n");
+ }
+ fprintf (stderr, "opcode=0x%08x\t", insn->opcode);
+ fprintf (stderr, "expand=0x%08x\t", insn->expand);
+ fprintf (stderr, "reloc = %s\t", Reloc[insn->reloc]);
+ fprintf (stderr, "highlow = %s\n", Highlow[insn->highlow]);
+ fprintf (stderr, "exp = {\n");
+ fprintf (stderr, "\t\tX_add_symbol = %s\n",
+ insn->exp.X_add_symbol ?
+ (S_GET_NAME (insn->exp.X_add_symbol) ?
+ S_GET_NAME (insn->exp.X_add_symbol) : "???") : "0");
+ fprintf (stderr, "\t\tX_sub_symbol = %s\n",
+ insn->exp.X_subtract_symbol ?
+ (S_GET_NAME (insn->exp.X_subtract_symbol) ?
+ S_GET_NAME (insn->exp.X_subtract_symbol) : "???") : "0");
+ fprintf (stderr, "\t\tX_add_number = %d\n",
+ insn->exp.X_add_number);
+ fprintf (stderr, "}\n");
+ return;
}
int
- md_parse_option(argP,cntP,vecP)
-char **argP;
-int *cntP;
-char ***vecP;
+md_parse_option (argP, cntP, vecP)
+ char **argP;
+ int *cntP;
+ char ***vecP;
{
- return 1;
+ return 1;
}
+#ifdef comment
/*
* I860 relocations are completely different, so it needs
* this machine dependent routine to emit them.
*/
void
- emit_machine_reloc(fixP, segment_address_in_file)
-register fixS *fixP;
-relax_addressT segment_address_in_file;
+emit_machine_reloc (fixP, segment_address_in_file)
+ register fixS *fixP;
+ relax_addressT segment_address_in_file;
{
- struct reloc_info_i860 ri;
- register symbolS *symbolP;
- extern char *next_object_file_charP;
- long add_number;
-
- memset((char *) &ri, '\0', sizeof(ri));
- for (; fixP; fixP = fixP->fx_next) {
-
- if (fixP->fx_r_type & ~0x3f) {
- as_fatal("fixP->fx_r_type = %d\n", fixP->fx_r_type);
- }
- ri.r_pcrel = fixP->fx_pcrel;
- ri.r_type = fixP->fx_r_type;
-
- if ((symbolP = fixP->fx_addsy) != NULL) {
- ri.r_address = fixP->fx_frag->fr_address +
- fixP->fx_where - segment_address_in_file;
- if ((symbolP->sy_type & N_TYPE) == N_UNDF) {
- ri.r_extern = 1;
- ri.r_symbolnum = symbolP->sy_number;
- } else {
- ri.r_extern = 0;
- ri.r_symbolnum = symbolP->sy_type & N_TYPE;
- }
- if (symbolP && symbolP->sy_frag) {
- ri.r_addend = symbolP->sy_frag->fr_address;
- }
- ri.r_type = fixP->fx_r_type;
- if (fixP->fx_pcrel) {
- /* preserve actual offset vs. pc + 4 */
- ri.r_addend -= (ri.r_address + 4);
- } else {
- ri.r_addend = fixP->fx_addnumber;
- }
-
- md_ri_to_chars((char *) &ri, ri);
- append(&next_object_file_charP, (char *)& ri, sizeof(ri));
- }
+ struct reloc_info_i860 ri;
+ register symbolS *symbolP;
+ extern char *next_object_file_charP;
+ long add_number;
+
+ memset ((char *) &ri, '\0', sizeof (ri));
+ for (; fixP; fixP = fixP->fx_next)
+ {
+
+ if (fixP->fx_r_type & ~0x3f)
+ {
+ as_fatal ("fixP->fx_r_type = %d\n", fixP->fx_r_type);
}
- return;
+ ri.r_pcrel = fixP->fx_pcrel;
+ ri.r_type = fixP->fx_r_type;
+
+ if ((symbolP = fixP->fx_addsy) != NULL)
+ {
+ ri.r_address = fixP->fx_frag->fr_address +
+ fixP->fx_where - segment_address_in_file;
+ if (!S_IS_DEFINED (symbolP))
+ {
+ ri.r_extern = 1;
+ ri.r_symbolnum = symbolP->sy_number;
+ }
+ else
+ {
+ ri.r_extern = 0;
+ ri.r_symbolnum = S_GET_TYPE (symbolP);
+ }
+ if (symbolP && symbolP->sy_frag)
+ {
+ ri.r_addend = symbolP->sy_frag->fr_address;
+ }
+ ri.r_type = fixP->fx_r_type;
+ if (fixP->fx_pcrel)
+ {
+ /* preserve actual offset vs. pc + 4 */
+ ri.r_addend -= (ri.r_address + 4);
+ }
+ else
+ {
+ ri.r_addend = fixP->fx_addnumber;
+ }
+
+ md_ri_to_chars ((char *) &ri, ri);
+ append (&next_object_file_charP, (char *) &ri, sizeof (ri));
+ }
+ }
+ return;
}
-/* Parse an operand that is machine-specific.
+#endif /* comment */
+
+#ifdef OBJ_AOUT
+
+/* on i860: 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 pcrel, bit 6 as extern, and the lower six bits as
+ relocation type (highlow 5-4). Next 4 bytes are long addend. */
+
+void
+tc_aout_fix_to_chars (where, fixP, segment_address_in_file)
+ char *where;
+ fixS *fixP;
+ relax_addressT segment_address_in_file;
+{
+ long r_index;
+ long r_extern;
+ long r_addend = 0;
+ long r_address;
+
+ know (fixP->fx_addsy);
+ know (!(fixP->fx_r_type & ~0x3f));
+
+ if (!S_IS_DEFINED (fixP->fx_addsy))
+ {
+ r_extern = 1;
+ r_index = fixP->fx_addsy->sy_number;
+ }
+ else
+ {
+ r_extern = 0;
+ r_index = S_GET_TYPE (fixP->fx_addsy);
+ }
+
+ md_number_to_chars (where,
+ r_address = fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
+ 4);
+
+ where[4] = (r_index >> 16) & 0x0ff;
+ where[5] = (r_index >> 8) & 0x0ff;
+ where[6] = r_index & 0x0ff;
+ where[7] = (((fixP->fx_pcrel << 7) & 0x80)
+ | ((r_extern << 6) & 0x40)
+ | (fixP->fx_r_type & 0x3F));
+
+ if (fixP->fx_addsy->sy_frag)
+ {
+ r_addend = fixP->fx_addsy->sy_frag->fr_address;
+ }
+
+ if (fixP->fx_pcrel)
+ {
+ /* preserve actual offset vs. pc + 4 */
+ r_addend -= (r_address + 4);
+ }
+ else
+ {
+ r_addend = fixP->fx_addnumber;
+ }
+
+ md_number_to_chars (&where[8], r_addend, 4);
+
+ return;
+} /* tc_aout_fix_to_chars() */
+
+#endif /* OBJ_AOUT */
+
+/* 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;
+md_operand (expressionP)
+ expressionS *expressionP;
{
}
/* ARGSUSED */
symbolS *
- md_undefined_symbol (name)
-char *name;
+md_undefined_symbol (name)
+ char *name;
{
- return 0;
+ return 0;
}
/* Round up a section size to the appropriate boundary. */
-long
- md_section_align (segment, size)
-segT segment;
-long size;
+valueT
+md_section_align (segment, size)
+ segT segment;
+ valueT size;
{
- return size; /* Byte alignment is fine */
+ return size; /* Byte alignment is fine */
}
/* Exactly what point is a PC-relative offset relative TO?
On the i860, they're relative to the address of the offset, plus
its size. (??? Is this right? FIXME-SOON!) */
long
- md_pcrel_from (fixP)
-fixS *fixP;
+md_pcrel_from (fixP)
+ fixS *fixP;
{
- return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
+ return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
}
void
- md_apply_fix(fixP, val)
-fixS *fixP;
-long val;
+md_apply_fix (fixP, val)
+ fixS *fixP;
+ long val;
{
- char *place = fixP->fx_where + fixP->fx_frag->fr_literal;
-
- if (!fixP->fx_bit_fixP) {
-
- switch (fixP->fx_im_disp) {
- case 0:
- fixP->fx_addnumber = val;
- md_number_to_imm(place, val, fixP->fx_size, fixP);
- break;
- case 1:
- md_number_to_disp (place,
- fixP->fx_pcrel ? val+fixP->fx_pcrel_adjust:val,
- fixP->fx_size);
- break;
- case 2: /* fix requested for .long .word etc */
- md_number_to_chars (place, val, fixP->fx_size);
- break;
- default:
- as_fatal("Internal error in md_apply_fix() in file \"%s\"", __FILE__);
- } /* OVE: maybe one ought to put _imm _disp _chars in one md-func */
- } else {
- md_number_to_field (place, val, fixP->fx_bit_fixP);
- }
-
- return;
-} /* md_apply_fix() */
+ char *place = fixP->fx_where + fixP->fx_frag->fr_literal;
+
+ /* looks to me like i860 never has bit fixes. Let's see. xoxorich. */
+ know (fixP->fx_bit_fixP == NULL);
+ if (!fixP->fx_bit_fixP)
+ {
+
+ /* also looks like fx_im_disp is always 0. Let's see. xoxorich. */
+ know (fixP->fx_im_disp == 0);
+ switch (fixP->fx_im_disp)
+ {
+ case 0:
+ fixP->fx_addnumber = val;
+ md_number_to_imm (place, val, fixP->fx_size, fixP);
+ break;
+ case 1:
+ md_number_to_disp (place,
+ fixP->fx_pcrel ? val + fixP->fx_pcrel_adjust : val,
+ fixP->fx_size);
+ break;
+ case 2: /* fix requested for .long .word etc */
+ md_number_to_chars (place, val, fixP->fx_size);
+ break;
+ default:
+ as_fatal ("Internal error in md_apply_fix() in file \"%s\"", __FILE__);
+ } /* OVE: maybe one ought to put _imm _disp _chars in one md-func */
+ }
+ else
+ {
+ md_number_to_field (place, val, fixP->fx_bit_fixP);
+ }
+
+ return;
+} /* md_apply_fix() */
/*
* Local Variables:
* fill-column: 131
* comment-column: 0
+ * End:
*/
/* end of tc-i860.c */
projects / binutils-gdb.git / commitdiff