From: rahnds Date: Wed, 23 Apr 1997 21:24:39 +0000 (+0000) Subject: Commit the gas and ld portions for the mvme88k port. X-Git-Url: http://artulab.com/gitweb/?a=commitdiff_plain;h=78bdfb15c74df54f731b7d216d826e0a08a0088d;p=openbsd Commit the gas and ld portions for the mvme88k port. --- diff --git a/gnu/usr.bin/gas/config/Makefile.mvme88k b/gnu/usr.bin/gas/config/Makefile.mvme88k new file mode 100644 index 00000000000..79ba9099b30 --- /dev/null +++ b/gnu/usr.bin/gas/config/Makefile.mvme88k @@ -0,0 +1,5 @@ +# from: @(#)Makefile.hp300 6.1 (Berkeley) 3/3/91 +# $Id: Makefile.mvme88k,v 1.1 1997/04/23 21:24:39 rahnds Exp $ + +#CFLAGS+= -DPIC +SRCS+= tc-mvme88k.c atof-ieee.c diff --git a/gnu/usr.bin/gas/config/tc-mvme88k.c b/gnu/usr.bin/gas/config/tc-mvme88k.c new file mode 100644 index 00000000000..8ad422b7035 --- /dev/null +++ b/gnu/usr.bin/gas/config/tc-mvme88k.c @@ -0,0 +1,1435 @@ +/* m88k.c -- Assembler for the Motorola 88000 + Contributed by Devon Bowen of Buffalo University + and Torbjorn Granlund of the Swedish Institute of Computer Science. + 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 "as.h" +#include "opcode/m88k.h" + +struct m88k_insn +{ + unsigned long opcode; + expressionS exp; + enum reloc_type reloc; +}; + +#if __STDC__ == 1 + +static int calcop(struct m88k_opcode *format, char *param, struct m88k_insn *insn); + +#else /* not __STDC__ */ + +static int calcop(); + +#endif /* not __STDC__ */ + +char *getval (); +char *get_reg (); +char *get_imm16 (); +char *get_bf (); +char *get_pcr (); +char *get_cmp (); +char *get_cnd (); +char *get_cr (); +char *get_fcr (); +char *get_vec9 (); + +struct field_val_assoc +{ + char *name; + unsigned val; +}; + +struct field_val_assoc cr_regs[] = +{ + {"PID", 0}, + {"PSR", 1}, + {"EPSR", 2}, + {"SSBR", 3}, + {"SXIP", 4}, + {"SNIP", 5}, + {"SFIP", 6}, + {"VBR", 7}, + {"DMT0", 8}, + {"DMD0", 9}, + {"DMA0", 10}, + {"DMT1", 11}, + {"DMD1", 12}, + {"DMA1", 13}, + {"DMT2", 14}, + {"DMD2", 15}, + {"DMA2", 16}, + {"SR0", 17}, + {"SR1", 18}, + {"SR2", 19}, + {"SR3", 20}, + + {NULL, 0}, +}; + +struct field_val_assoc fcr_regs[] = +{ + {"FPECR", 0}, + {"FPHS1", 1}, + {"FPLS1", 2}, + {"FPHS2", 3}, + {"FPLS2", 4}, + {"FPPT", 5}, + {"FPRH", 6}, + {"FPRL", 7}, + {"FPIT", 8}, + + {"FPSR", 62}, + {"FPCR", 63}, + + {NULL, 0}, +}; + +struct field_val_assoc cmpslot[] = +{ +/* Integer Floating point */ + {"nc", 0}, + {"cp", 1}, + {"eq", 2}, + {"ne", 3}, + {"gt", 4}, + {"le", 5}, + {"lt", 6}, + {"ge", 7}, + {"hi", 8}, {"ou", 8}, + {"ls", 9}, {"ib", 9}, + {"lo", 10}, {"in", 10}, + {"hs", 11}, {"ob", 11}, + + {NULL, 0}, +}; + +struct field_val_assoc cndmsk[] = +{ + {"gt0", 1}, + {"eq0", 2}, + {"ge0", 3}, + {"lt0", 12}, + {"ne0", 13}, + {"le0", 14}, + + {NULL, 0}, +}; + +extern char *myname; +static struct hash_control *op_hash = NULL; + +/* These bits should be turned off in the first address of every segment */ +int md_seg_align = 7; + +/* This is the number to put at the beginning of the a.out file */ +long omagic = OMAGIC; + +/* These chars start a comment anywhere in a source file (except inside + another comment */ +const char comment_chars[] = "#|"; + +/* These chars only start a comment at the beginning of a line. */ +const char line_comment_chars[] = ";"; + +/* Chars that can be used to separate mant from exp in floating point nums */ +char EXP_CHARS[] = "eE"; + +/* Chars that mean this number is a floating point constant */ +/* as in 0f123.456 */ +/* or 0H1.234E-12 (see exp chars above) */ +char FLT_CHARS[] = "dDfF"; + +extern void float_cons (), cons (), s_globl (), s_line (), + s_space (), s_set (), stringer (), s_lcomm (); +static void s_bss (); + +const pseudo_typeS md_pseudo_table[] = { + {"align", s_align_bytes, 0 }, + {"def", s_set, 0}, + {"dfloat", float_cons, 'd'}, + {"ffloat", float_cons, 'f'}, + {"global", s_globl, 0}, + {"half", cons, 2 }, + {"bss", s_bss, 0}, + {"string", stringer, 0}, + {"word", cons, 4 }, + {"zero", s_space, 0}, + {0} +}; + +const int md_reloc_size = 12; /* Size of relocation record */ + +void +md_begin () +{ + char *retval = NULL; + unsigned int i = 0; + + /* initialize hash table */ + + op_hash = hash_new (); + if (op_hash == NULL) + as_fatal ("Could not initialize hash table"); + + /* loop until you see the end of the list */ + + while (*m88k_opcodes[i].name) + { + char *name = m88k_opcodes[i].name; + + /* hash each mnemonic and record its position */ + + retval = hash_insert (op_hash, name, &m88k_opcodes[i]); + + if (retval != NULL && *retval != '\0') + as_fatal ("Can't hash instruction '%s':%s", + m88k_opcodes[i].name, retval); + + /* skip to next unique mnemonic or end of list */ + + for (i++; !strcmp (m88k_opcodes[i].name, name); i++) + ; + } +} + +int +md_parse_option (argP, cntP, vecP) + char **argP; + int *cntP; + char ***vecP; +{ + as_warn ("unknown option: -%s", *argP); + return(0); +} + +void +md_assemble (op) + char *op; +{ + char *param, *thisfrag; + struct m88k_opcode *format; + struct m88k_insn insn; + + assert (op); + + /* skip over instruction to find parameters */ + + for (param = op; *param != 0 && !isspace (*param); param++) + ; + if (*param != 0) + *param++ = 0; + + /* try to find the instruction in the hash table */ + + if ((format = (struct m88k_opcode *) hash_find (op_hash, op)) == NULL) + { + as_fatal ("Invalid mnemonic '%s'", op); + return; + } + + /* try parsing this instruction into insn */ + + insn.exp.X_add_symbol = 0; + insn.exp.X_subtract_symbol = 0; + insn.exp.X_add_number = 0; + insn.exp.X_seg = 0; + insn.reloc = NO_RELOC; + + while (!calcop(format, param, &insn)) + { + /* if it doesn't parse try the next instruction */ + + if (!strcmp (format[0].name, format[1].name)) + format++; + else + { + as_fatal ("Parameter syntax error"); + return; + } + } + + /* grow the current frag and plop in the opcode */ + + thisfrag = frag_more (4); + md_number_to_chars (thisfrag, insn.opcode, 4); + + /* if this instruction requires labels mark it for later */ + + switch (insn.reloc) + { + case NO_RELOC: + break; + + case RELOC_LO16: + case RELOC_HI16: + fix_new (frag_now, + thisfrag - frag_now->fr_literal + 2, + 2, + insn.exp.X_add_symbol, + insn.exp.X_subtract_symbol, + insn.exp.X_add_number, + 0, + insn.reloc); + break; + + case RELOC_IW16: + fix_new (frag_now, + thisfrag - frag_now->fr_literal, + 4, + insn.exp.X_add_symbol, + insn.exp.X_subtract_symbol, + insn.exp.X_add_number, + 0, + insn.reloc); + break; + + case RELOC_PC16: + fix_new (frag_now, + thisfrag - frag_now->fr_literal + 2, + 2, + insn.exp.X_add_symbol, + insn.exp.X_subtract_symbol, + insn.exp.X_add_number, + 1, + insn.reloc); + break; + + case RELOC_PC26: + fix_new (frag_now, + thisfrag - frag_now->fr_literal, + 4, + insn.exp.X_add_symbol, + insn.exp.X_subtract_symbol, + insn.exp.X_add_number, + 1, + insn.reloc); + break; + + default: + as_fatal ("Unknown relocation type"); + break; + } +} + +int +calcop (format, param, insn) + struct m88k_opcode *format; + char *param; + struct m88k_insn *insn; +{ + char *fmt = format->op_spec; + int f; + unsigned val; + unsigned opcode; + + insn->opcode = format->opcode; + opcode = 0; + + for (;;) + { + if (param == 0) + return 0; + f = *fmt++; + switch (f) + { + case 0: + insn->opcode |= opcode; + return *param == 0; + + default: + if (f != *param++) + return 0; + break; + + case 'd': + param = get_reg (param, &val); + opcode |= val << 21; + break; + + case '1': + param = get_reg (param, &val); + opcode |= val << 16; + break; + + case '2': + param = get_reg (param, &val); + opcode |= val; + break; + + case '3': + param = get_reg (param, &val); + opcode |= (val << 16) | val; + break; + + case 'I': + param = get_imm16 (param, insn); + break; + + case 'b': + param = get_bf (param, &val); + opcode |= val; + break; + + case 'p': + param = get_pcr (param, insn, RELOC_PC16); + break; + + case 'P': + param = get_pcr (param, insn, RELOC_PC26); + break; + + case 'B': + param = get_cmp (param, &val); + opcode |= val; + break; + + case 'M': + param = get_cnd (param, &val); + opcode |= val; + break; + + case 'c': + param = get_cr (param, &val); + opcode |= val << 5; + break; + + case 'f': + param = get_fcr (param, &val); + opcode |= val << 5; + break; + + case 'V': + param = get_vec9 (param, &val); + opcode |= val; + break; + + case '?': + /* Having this here repeats the warning somtimes. + But can't we stand that? */ + as_warn ("Use of obsolete instruction"); + break; + } + } +} + +char * +match_name (param, assoc_tab, valp) + char *param; + struct field_val_assoc *assoc_tab; + unsigned *valp; +{ + int i; + char *name; + int name_len; + + for (i = 0;; i++) + { + name = assoc_tab[i].name; + if (name == NULL) + return NULL; + name_len = strlen (name); + if (!strncmp (param, name, name_len)) + { + *valp = assoc_tab[i].val; + return param + name_len; + } + } +} + +char * +get_reg (param, regnop) + char *param; + unsigned *regnop; +{ + unsigned c; + unsigned regno; + + c = *param++; + if (c == 'r') + { + regno = *param++ - '0'; + if (regno < 10) + { + if (regno == 0) + { + *regnop = 0; + return param; + } + c = *param - '0'; + if (c < 10) + { + regno = regno * 10 + c; + if (c < 32) + { + *regnop = regno; + return param + 1; + } + } + else + { + *regnop = regno; + return param; + } + } + return NULL; + } + else if (c == 's' && param[0] == 'p') + { + *regnop = 31; + return param + 1; + } + + return 0; +} + +char * +get_imm16 (param, insn) + char *param; + struct m88k_insn *insn; +{ + enum reloc_type reloc = NO_RELOC; + unsigned int val; + segT seg; + char *save_ptr; + + if (!strncmp (param, "hi16", 4) && !isalnum (param[4])) + { + reloc = RELOC_HI16; + param += 4; + } + else if (!strncmp (param, "lo16", 4) && !isalnum (param[4])) + { + reloc = RELOC_LO16; + param += 4; + } + else if (!strncmp (param, "iw16", 4) && !isalnum (param[4])) + { + reloc = RELOC_IW16; + param += 4; + } + + save_ptr = input_line_pointer; + input_line_pointer = param; + seg = expression (&insn->exp); + param = input_line_pointer; + input_line_pointer = save_ptr; + + val = insn->exp.X_add_number; + + if (seg == SEG_ABSOLUTE) + { + /* Insert the value now, and reset reloc to NO_RELOC. */ + if (reloc == NO_RELOC) + { + /* Warn about too big expressions if not surrounded by xx16. */ + if (val > 0xffff) + as_warn ("Expression truncated to 16 bits"); + } + + if (reloc == RELOC_HI16) + val >>= 16; + + insn->opcode |= val & 0xffff; + reloc = NO_RELOC; + } + else if (reloc == NO_RELOC) + /* We accept a symbol even without lo16, hi16, etc, and assume + lo16 was intended. */ + reloc = RELOC_LO16; + + insn->reloc = reloc; + + return param; +} + +char * +get_pcr (param, insn, reloc) + char *param; + struct m88k_insn *insn; + enum reloc_type reloc; +{ + char *saveptr, *saveparam; + segT seg; + + saveptr = input_line_pointer; + input_line_pointer = param; + + seg = expression (&insn->exp); + + saveparam = input_line_pointer; + input_line_pointer = saveptr; + + /* Botch: We should relocate now if SEG_ABSOLUTE. */ + insn->reloc = reloc; + + return saveparam; +} + +char * +get_cmp (param, valp) + char *param; + unsigned *valp; +{ + unsigned int val; + char *save_ptr; + + save_ptr = param; + + param = match_name (param, cmpslot, valp); + val = *valp; + + if (param == NULL) + { + param = save_ptr; + + save_ptr = input_line_pointer; + input_line_pointer = param; + val = get_absolute_expression (); + param = input_line_pointer; + input_line_pointer = save_ptr; + + if (val >= 32) + { + as_warn ("Expression truncated to 5 bits"); + val %= 32; + } + } + + *valp = val << 21; + return param; +} + +char * +get_cnd (param, valp) + char *param; + unsigned *valp; +{ + unsigned int val; + + if (isdigit (*param)) + { + param = getval (param, &val); + + if (val >= 32) + { + as_warn ("Expression truncated to 5 bits"); + val %= 32; + } + } + else + { + if (isupper (*param)) + *param = tolower (*param); + + if (isupper (param[1])) + param[1] = tolower (param[1]); + + param = match_name (param, cndmsk, valp); + + if (param == NULL) + return NULL; + + val = *valp; + } + + *valp = val << 21; + return param; +} + +char * +get_bf2 (param, bc) + char *param; + int bc; +{ + int depth = 0; + int c; + + for (;;) + { + c = *param; + if (c == 0) + return param; + else if (c == '(') + depth++; + else if (c == ')') + depth--; + else if (c == bc && depth <= 0) + return param; + param++; + } +} + +char * +get_bf_offset_expression (param, offsetp) + char *param; + unsigned *offsetp; +{ + unsigned offset; + + if (isalpha (param[0])) + { + if (isupper (param[0])) + param[0] = tolower (param[0]); + if (isupper (param[1])) + param[1] = tolower (param[1]); + + param = match_name (param, cmpslot, offsetp); + + return param; + } + else + { + input_line_pointer = param; + offset = get_absolute_expression (); + param = input_line_pointer; + } + + *offsetp = offset; + return param; +} + +char * +get_bf (param, valp) + char *param; + unsigned *valp; +{ + unsigned offset = 0; + unsigned width = 0; + char *xp; + char *save_ptr; + + xp = get_bf2 (param, '<'); + + save_ptr = input_line_pointer; + input_line_pointer = param; + if (*xp == 0) + { + /* We did not find '<'. We have an offset (width implicitly 32). */ + param = get_bf_offset_expression (param, &offset); + if (param == NULL) + return NULL; + input_line_pointer = save_ptr; + } + else + { + *xp++ = 0; /* Overwrite the '<' */ + param = get_bf2 (xp, '>'); + if (*param == 0) + return NULL; + *param++ = 0; /* Overwrite the '>' */ + + width = get_absolute_expression (); + xp = get_bf_offset_expression (xp, &offset); + input_line_pointer = save_ptr; + + if (xp + 1 != param) + return NULL; + } + + *valp = ((width % 32) << 5) | (offset % 32); + + return param; +} + +char * +get_cr (param, regnop) + char *param; + unsigned *regnop; +{ + unsigned regno; + unsigned c; +/* int i; FIXME remove this */ +/* int name_len; FIXME remove this */ + + if (!strncmp (param, "cr", 2)) + { + param += 2; + + regno = *param++ - '0'; + if (regno < 10) + { + if (regno == 0) + { + *regnop = 0; + return param; + } + c = *param - '0'; + if (c < 10) + { + regno = regno * 10 + c; + if (c < 64) + { + *regnop = regno; + return param + 1; + } + } + else + { + *regnop = regno; + return param; + } + } + return NULL; + } + + param = match_name (param, cr_regs, regnop); + + return param; +} + +char * +get_fcr (param, regnop) + char *param; + unsigned *regnop; +{ + unsigned regno; + unsigned c; +/* int i; FIXME remove this */ +/* int name_len; FIXME: remove this */ + + if (!strncmp (param, "fcr", 3)) + { + param += 3; + + regno = *param++ - '0'; + if (regno < 10) + { + if (regno == 0) + { + *regnop = 0; + return param; + } + c = *param - '0'; + if (c < 10) + { + regno = regno * 10 + c; + if (c < 64) + { + *regnop = regno; + return param + 1; + } + } + else + { + *regnop = regno; + return param; + } + } + return NULL; + } + + param = match_name (param, fcr_regs, regnop); + + return param; +} + +char * +get_vec9 (param, valp) + char *param; + unsigned *valp; +{ + unsigned val; + char *save_ptr; + + save_ptr = input_line_pointer; + input_line_pointer = param; + val = get_absolute_expression (); + param = input_line_pointer; + input_line_pointer = save_ptr; + + if (val >= 1 << 9) + as_warn ("Expression truncated to 9 bits"); + + *valp = val % (1 << 9); + + return param; +} + +#define hexval(z) \ + (isdigit (z) ? (z) - '0' : \ + islower (z) ? (z) - 'a' + 10 : \ + isupper (z) ? (z) - 'A' + 10 : -1) + +char * +getval (param, valp) + char *param; + unsigned int *valp; +{ + unsigned int val = 0; + unsigned int c; + + c = *param++; + if (c == '0') + { + c = *param++; + if (c == 'x' || c == 'X') + { + c = *param++; + c = hexval (c); + while (c < 16) + { + val = val * 16 + c; + c = *param++; + c = hexval (c); + } + } + else + { + c -= '0'; + while (c < 8) + { + val = val * 8 + c; + c = *param++ - '0'; + } + } + } + else + { + c -= '0'; + while (c < 10) + { + val = val * 10 + c; + c = *param++ - '0'; + } + } + + *valp = val; + return param - 1; +} + +void +md_number_to_chars (buf, val, nbytes) +char *buf; +long val; +int nbytes; +{ + switch (nbytes) + { + case 4: + *buf++ = val >> 24; + *buf++ = val >> 16; + case 2: + *buf++ = val >> 8; + case 1: + *buf = val; + break; + + default: + abort (); + } +} + +#ifdef comment + +void +md_number_to_imm (buf, val, nbytes, fixP, seg_type) +unsigned char *buf; +unsigned int val; +int nbytes; +fixS *fixP; +int seg_type; +{ + if (seg_type != N_TEXT || fixP->fx_r_type == NO_RELOC) + { + switch (nbytes) + { + case 4: + *buf++ = val >> 24; + *buf++ = val >> 16; + case 2: + *buf++ = val >> 8; + case 1: + *buf = val; + break; + + default: + abort (); + } + return; + } + + switch (fixP->fx_r_type) + { + case RELOC_IW16: + buf[2] = val >> 8; + buf[3] = val; + break; + + case RELOC_LO16: + buf[0] = val >> 8; + buf[1] = val; + break; + + case RELOC_HI16: + buf[0] = val >> 24; + buf[1] = val >> 16; + break; + + case RELOC_PC16: + val += 4; + buf[0] = val >> 10; + buf[1] = val >> 2; + break; + + case RELOC_PC26: + val += 4; + buf[0] |= (val >> 26) & 0x03; + buf[1] = val >> 18; + buf[2] = val >> 10; + buf[3] = val >> 2; + break; + + case RELOC_32: + buf[0] = val >> 24; + buf[1] = val >> 16; + buf[2] = val >> 8; + buf[3] = val; + break; + + default: + as_fatal ("Bad relocation type"); + break; + } +} +#endif /* comment */ + +/* Apply a fixS to the frags, now that we know the value it ought to + hold. */ + +void md_apply_fix(fixP, val) +fixS *fixP; +long val; +{ + char *buf = fixP->fx_where + fixP->fx_frag->fr_literal; + + fixP->fx_addnumber = val; + + + switch (fixP->fx_r_type) { + + case RELOC_IW16: + buf[2] = val >> 8; + buf[3] = val; + break; + + case RELOC_LO16: + buf[0] = val >> 8; + buf[1] = val; + break; + + case RELOC_HI16: + buf[0] = val >> 24; + buf[1] = val >> 16; + break; + + case RELOC_PC16: + val += 4; + buf[0] = val >> 10; + buf[1] = val >> 2; + break; + + case RELOC_PC26: + val += 4; + buf[0] |= (val >> 26) & 0x03; + buf[1] = val >> 18; + buf[2] = val >> 10; + buf[3] = val >> 2; + break; + + case RELOC_32: + buf[0] = val >> 24; + buf[1] = val >> 16; + buf[2] = val >> 8; + buf[3] = val; + break; + + case NO_RELOC: + switch (fixP->fx_size) { + case 4: + *buf++ = val >> 24; + *buf++ = val >> 16; + case 2: + *buf++ = val >> 8; + case 1: + *buf = val; + break; + + default: + abort (); + } + + default: + as_bad("bad relocation type: 0x%02x", fixP->fx_r_type); + break; + } + + return; +} /* md_apply_fix() */ + +void +md_number_to_disp (buf, val, nbytes) +char *buf; +int val; +int nbytes; +{ + as_fatal ("md_number_to_disp not defined"); + md_number_to_chars (buf, val, nbytes); +} + +void +md_number_to_field (buf, val, nbytes) +char *buf; +int val; +int nbytes; +{ + as_fatal ("md_number_to_field not defined"); + md_number_to_chars (buf, val, nbytes); +} + +#define MAX_LITTLENUMS 6 + +/* 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. + */ +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 */ +} + +int md_short_jump_size = 4; + +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; +{ + ptr[0] = 0xc0; ptr[1] = 0x00; ptr[2] = 0x00; ptr[3] = 0x00; + fix_new (frag, + ptr - frag->fr_literal, + 4, + to_symbol, + (symbolS *) 0, + (long int) 0, + 0, + RELOC_PC26); /* Botch: Shouldn't this be RELOC_PC16? */ +} + +int md_long_jump_size = 4; + +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; +{ + ptr[0] = 0xc0; ptr[1] = 0x00; ptr[2] = 0x00; ptr[3] = 0x00; + fix_new (frag, + ptr - frag->fr_literal, + 4, + to_symbol, + (symbolS *) 0, + (long int) 0, + 0, + RELOC_PC26); +} + +int +md_estimate_size_before_relax (fragP, segment_type) + fragS *fragP; + segT segment_type; +{ + as_fatal("Relaxation should never occur"); + return(0); +} + +const relax_typeS md_relax_table[] = {0}; + +void +md_convert_frag (headers, fragP) +object_headers *headers; + fragS *fragP; +{ + as_fatal ("Relaxation should never occur"); +} + +void +md_end () +{ +} + +#ifdef comment + +/* + * Risc relocations are completely different, so it needs + * this machine dependent routine to emit them. + */ +void +emit_relocations (fixP, segment_address_in_file) + fixS *fixP; + relax_addressT segment_address_in_file; +{ + struct reloc_info_m88k ri; + symbolS *symbolP; + extern char *next_object_file_charP; + + bzero ((char *) &ri, sizeof (ri)); + for (; fixP; fixP = fixP->fx_next) { + + if (fixP->fx_r_type >= NO_RELOC) { + fprintf (stderr, "fixP->fx_r_type = %d\n", fixP->fx_r_type); + abort (); + } + + 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) { +/* ri.r_addend -= fixP->fx_where; */ + ri.r_addend -= ri.r_address; + } else { + ri.r_addend = fixP->fx_addnumber; + } + +/* md_ri_to_chars ((char *) &ri, ri); */ + append (&next_object_file_charP, (char *)& ri, sizeof (ri)); + } + } + return; +} +#endif /* comment */ + +/* Translate internal representation of relocation info to target format. + + On m88k: 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, & 4 unused, and the lower four bits as relocation + type. + 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); + + 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); + } + + /* this is easy */ + md_number_to_chars(where, + r_address = fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file, + 4); + + /* now the fun stuff */ + where[4] = (r_index >> 16) & 0x0ff; + where[5] = (r_index >> 8) & 0x0ff; + where[6] = r_index & 0x0ff; + where[7] = ((r_extern << 7) & 0x80) | (0 & 0x70) | (fixP->fx_r_type & 0xf); + + /* Also easy */ + if (fixP->fx_addsy->sy_frag) { + r_addend = fixP->fx_addsy->sy_frag->fr_address; + } + + if (fixP->fx_pcrel) { + r_addend -= r_address; + } else { + r_addend = fixP->fx_addnumber; + } + + md_number_to_chars(&where[8], r_addend, 4); + + return; +} /* tc_aout_fix_to_chars() */ + + +static void +s_bss() +{ + char *name; + char c; + char *p; + int temp, bss_align = 1; + symbolS *symbolP; + extern char is_end_of_line[256]; + + name = input_line_pointer; + c = get_symbol_end(); + p = input_line_pointer; + *p = c; + SKIP_WHITESPACE(); + if ( * input_line_pointer != ',' ) + { + as_warn("Expected comma after name"); + ignore_rest_of_line(); + return; + } + input_line_pointer ++; + if ((temp = get_absolute_expression()) < 0) + { + as_warn("BSS length (%d.) <0! Ignored.", temp); + ignore_rest_of_line(); + return; + } + *p = 0; + symbolP = symbol_find_or_make(name); + *p = c; + if (*input_line_pointer == ',') + { + input_line_pointer++; + bss_align = get_absolute_expression(); + while (local_bss_counter % bss_align != 0) + local_bss_counter++; + } + + if (!S_IS_DEFINED(symbolP) + || (S_GET_SEGMENT(symbolP) == SEG_BSS + && S_GET_VALUE(symbolP) == local_bss_counter)) { + S_SET_VALUE(symbolP, local_bss_counter); + S_SET_SEGMENT(symbolP, SEG_BSS); + symbolP->sy_frag = &bss_address_frag; + local_bss_counter += temp; + } else { + as_warn( "Ignoring attempt to re-define symbol from %d. to %d.", + S_GET_VALUE(symbolP), local_bss_counter ); + } + while (!is_end_of_line[*input_line_pointer]) + { + input_line_pointer++; + } + + return; +} + +/* 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; +{ +} /* md_operand() */ + +/* Round up a section size to the appropriate boundary. */ +long md_section_align(segment, size) +segT segment; +long size; +{ + return((size + 7) & ~7); /* Round all sects to multiple of 8 */ +} /* md_section_align() */ + +/* Exactly what point is a PC-relative offset relative TO? + On the sparc, they're relative to the address of the offset, plus + its size. This gets us to the following instruction. + (??? Is this right? FIXME-SOON) */ +long md_pcrel_from(fixP) +fixS *fixP; +{ + return(fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address); +} /* md_pcrel_from() */ + + /* end of tc-m88k.c */ diff --git a/gnu/usr.bin/gas/config/tc-mvme88k.h b/gnu/usr.bin/gas/config/tc-mvme88k.h new file mode 100644 index 00000000000..510b68703a1 --- /dev/null +++ b/gnu/usr.bin/gas/config/tc-mvme88k.h @@ -0,0 +1,42 @@ +/* m88k.h -- Assembler for the Motorola 88000 + Contributed by Devon Bowen of Buffalo University + and Torbjorn Granlund of the Swedish Institute of Computer Science. + 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. */ + +#define TC_M88K 1 + +#define MID_M88K 151 + +#define AOUT_MACHTYPE MID_M88K +#define LOCAL_LABELS_FB + +#define NO_LISTING +#define NO_DOT_PSEUDOS + +#define ALLOW_ATSIGN +#define AT 3 +/* m88k allows @ as the first char in a local label */ +#define LOCAL_LABEL(name) (name[0] == '@' \ + && ( name[1] == 'L' || name[1] == '.' )) + +#define tc_crawl_symbol_chain(a) {;} /* not used */ +#define tc_headers_hook(a) {;} /* not used */ +#define tc_aout_pre_write_hook(x) {;} /* not used */ + + /* end of tc-m88k.h */ diff --git a/gnu/usr.bin/ld/mvme88k/md.c b/gnu/usr.bin/ld/mvme88k/md.c new file mode 100644 index 00000000000..20c6a53ca9c --- /dev/null +++ b/gnu/usr.bin/ld/mvme88k/md.c @@ -0,0 +1,511 @@ +/* + * Copyright (c) 1993 Paul Kranenburg + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Paul Kranenburg. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * $Id: md.c,v 1.1 1997/04/23 21:24:41 rahnds Exp $ + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "ld.h" + +/* + * Get relocation addend corresponding to relocation record RP + * from address ADDR + */ +long +md_get_addend(rp, addr) +struct relocation_info_m88k *rp; +unsigned char *addr; +{ + return rp->r_addend; +} + +/* + * Put RELOCATION at ADDR according to relocation record RP. + */ +void +md_relocate(rp, relocation, addr, relocatable_output) +struct relocation_info_m88k *rp; +long relocation; +unsigned char *addr; +{ + if (relocatable_output) { + /* + * Store relocation where the next link-edit run + * will look for it. + */ + rp->r_addend = relocation; + return; + } + + switch ((rp->r_type)) { + case RELOC_LO16: + put_short(addr,relocation & 0xffff); + break; + case RELOC_HI16: + put_short(addr,(relocation >>16) & 0xffff); + break; + case RELOC_PC16: + put_short(addr,(relocation)>>2); + break; + case RELOC_PC26: + put_b26(addr,(relocation)>>2); + break; + case RELOC_32: + put_long(addr,relocation); + break; + case RELOC_IW16: + printf ("oops\n"); exit(100); + break; + case NO_RELOC: + break; + case RELOC_GLOB_DAT: + put_long(addr,relocation); + break; +/* + case RELOC_JMP_SLOT: + md_make_jmpslot(addr,, + break; +*/ + case RELOC_RELATIVE: + printf("reloc_rel not supported %x\n",addr); + exit (15); + break; + + default: + errx(1, "Unsupported relocation size: %x", + (rp->r_type)); + } +#ifdef RTLD + _cachectl (addr, RELOC_TARGET_SIZE(rp)); /* maintain cache coherency */ +#endif +} + +/* + * Machine dependent part of claim_rrs_reloc(). + * Set RRS relocation type. + */ +int +md_make_reloc(rp, r, type) +struct relocation_info_m88k *rp, *r; +int type; +{ + r->r_address = rp->r_address; + r->r_type = rp->r_type; + r->r_jmptable = rp->r_jmptable; + r->r_pcrel = rp->r_pcrel; + r->r_baserel = rp->r_baserel; + r->r_extern = rp->r_extern; + r->r_symbolnum = rp->r_symbolnum; + r->r_addend = rp->r_addend; + + return 0; +} + +/* + * Set up a transfer from jmpslot at OFFSET (relative to the PLT table) + * to the binder slot (which is at offset 0 of the PLT). + */ +void +md_make_jmpslot(sp, offset, index) +jmpslot_t *sp; +long offset; +long index; +{ + /* + * On m68k machines, a long branch offset is relative to + * the address of the offset. + */ + u_long fudge = - (sizeof(sp->opcode) + offset); + + sp->opcode = BSRL; + sp->addr[0] = fudge >> 16; + sp->addr[1] = fudge; + sp->reloc_index = index; +#ifdef RTLD + _cachectl (sp, 6); /* maintain cache coherency */ +#endif +} + +/* + * Set up a "direct" transfer (ie. not through the run-time binder) from + * jmpslot at OFFSET to ADDR. Used by `ld' when the SYMBOLIC flag is on, + * and by `ld.so' after resolving the symbol. + * On the m68k, we use the BRA instruction which is PC relative, so no + * further RRS relocations will be necessary for such a jmpslot. + */ +void +md_fix_jmpslot(sp, offset, addr) +jmpslot_t *sp; +long offset; +u_long addr; +{ + u_long fudge = addr - (sizeof(sp->opcode) + offset); + + sp->opcode = BRAL; + sp->addr[0] = fudge >> 16; + sp->addr[1] = fudge; + sp->reloc_index = 0; +#ifdef RTLD + _cachectl (sp, 6); /* maintain cache coherency */ +#endif +} + +/* + * Update the relocation record for a RRS jmpslot. + */ +void +md_make_jmpreloc(rp, r, type) +struct relocation_info_m88k *rp, *r; +int type; +{ + jmpslot_t *sp; + + /* + * Fix relocation address to point to the correct + * location within this jmpslot. + */ + r->r_address += sizeof(sp->opcode); + +#if 0 + /* Relocation size */ + r->r_length = 2; +#endif + + /* Set relocation type */ + r->r_jmptable = 1; +#if 0 + if (type & RELTYPE_RELATIVE) + r->r_relative = 1; +#endif + +printf("jmp reloc not supported \n"); +exit (15); +} + +/* + * Set relocation type for a RRS GOT relocation. + */ +void +md_make_gotreloc(rp, r, type) +struct relocation_info_m88k *rp, *r; +int type; +{ +#if 0 + r->r_baserel = 1; + if (type & RELTYPE_RELATIVE) + r->r_relative = 1; + + /* Relocation size */ + r->r_length = 2; +#endif +printf("got not supported \n"); +exit (15); +} + +/* + * Set relocation type for a RRS copy operation. + */ +void +md_make_cpyreloc(rp, r) +struct relocation_info_m88k *rp, *r; +{ + r->r_address = rp->r_address; + r->r_type = rp->r_type; + r->r_jmptable = rp->r_jmptable; + r->r_pcrel = rp->r_pcrel; + r->r_baserel = rp->r_baserel; + r->r_extern = rp->r_extern; + r->r_symbolnum = rp->r_symbolnum; + r->r_addend = rp->r_addend; +} + +void +md_set_breakpoint(where, savep) +long where; +long *savep; +{ + *savep = *(long *)where; + *(short *)where = BPT; +} + +#ifndef MID_M88K +#define MID_M88K 151 +#endif + +#ifndef RTLD +/* + * Initialize (output) exec header such that useful values are + * obtained from subsequent N_*() macro evaluations. + */ +void +md_init_header(hp, magic, flags) +struct exec *hp; +int magic, flags; +{ + if (oldmagic) + hp->a_midmag = oldmagic; + else + N_SETMAGIC((*hp), magic, MID_M88K, flags); + + /* TEXT_START depends on the value of outheader.a_entry. */ + if (!(link_mode & SHAREABLE)) + hp->a_entry = PAGSIZ; +} + +/* + * Check for acceptable foreign machine Ids + */ +int +md_midcompat(hp) +struct exec *hp; +{ + int mid = N_GETMID(*hp); + + if (mid == MID_M88K ) + return 1; +#if 0 + return (((md_swap_long(hp->a_midmag)&0x00ff0000) >> 16) == MID_SUN020); +#endif + return 0; +} +#endif /* RTLD */ + + +#ifdef NEED_SWAP +/* + * Byte swap routines for cross-linking. + */ + +void +md_swapin_exec_hdr(h) +struct exec *h; +{ + int skip = 1; + + if (!N_BADMAG(*h)) + skip = 1; + + swap_longs((long *)h + skip, sizeof(*h)/sizeof(long) - skip); +} + +void +md_swapout_exec_hdr(h) +struct exec *h; +{ + /* NetBSD: Always leave magic alone -- unless on little endian*/ + int skip = 1; +#if 0 + if (N_GETMAGIC(*h) == OMAGIC) + skip = 0; +#endif + + swap_longs((long *)h + skip, sizeof(*h)/sizeof(long) - skip); +} + + +void +md_swapin_reloc(r, n) +struct relocation_info_m88k *r; +int n; +{ + struct r_relocation_info_m88k r_r; + int *rev_int; + + if (sizeof (struct relocation_info_m88k) != sizeof (struct r_relocation_info_m88k)){ + fprintf(stderr, "fatal: relocation entry swapin\n"); + exit(23); + } + for (; n; n--, r++) { + + memcpy(&r_r,r,sizeof (struct relocation_info_m88k)); + r->r_address = md_swap_long(r_r.r_address); + r->r_addend = md_swap_long(r_r.r_addend); + rev_int = (((int *)(&r_r)) +1); + *rev_int = md_swap_long(*rev_int); + + + r->r_symbolnum = r_r.r_symbolnum; + r->r_extern = r_r.r_extern; + r->r_type = r_r.r_type; + switch(r->r_type){ + case RELOC_LO16: + case RELOC_HI16: + r->r_baserel =1; + break; + case RELOC_PC16: + case RELOC_PC26: + r->r_pcrel =1; + r->r_baserel =1; + break; + case RELOC_32: + r->r_jmptable =1; + break; + case RELOC_IW16: + break; + } +#if 0 +printf("%08x: %5x %4x %4x\n", + r->r_address, + r->r_symbolnum, + r->r_extern, + r->r_type); +#endif + } +} + +void +md_swapout_reloc(r, n) +struct relocation_info_m88k *r; +int n; +{ + int *rev_int; + struct r_relocation_info_m88k r_r; + + for (; n; n--, r++) { + r_r.r_address = md_swap_long(r->r_address); + r_r.r_addend = md_swap_long(r->r_addend); + r_r.r_symbolnum = r->r_symbolnum; + r_r.r_extern = r->r_extern; + r_r.r_type = r->r_type; + rev_int = (((int *)(&r_r)) +1); + *rev_int = md_swap_long(*rev_int); + memcpy(r,&r_r,sizeof (struct relocation_info_m88k)); + } +} + +void +md_swapout_jmpslot(j, n) +jmpslot_t *j; +int n; +{ + for (; n; n--, j++) { + j->opcode = md_swap_short(j->opcode); + j->addr[0] = md_swap_short(j->addr[0]); + j->addr[1] = md_swap_short(j->addr[1]); + j->reloc_index = md_swap_short(j->reloc_index); + } +} + +#else /* ! defined(NEEDSWAP) */ +void +md_in_reloc(r, n) +struct relocation_info_m88k *r; +int n; +{ + for (; n; n--, r++) { + + switch(r->r_type){ + case RELOC_LO16: + case RELOC_HI16: +/* r->r_baserel =1; */ + break; + case RELOC_PC16: + case RELOC_PC26: + r->r_pcrel =1; +/* r->r_baserel =1; */ + break; + case RELOC_32: + /* r->r_jmptable =1; */ + break; + case RELOC_IW16: + break; + case RELOC_GLOB_DAT: + break; +#if 1 + case RELOC_JMP_SLOT: + /* r->r_jmptable =1; */ + break; +#endif + case RELOC_RELATIVE: + r->r_pcrel =1; + break; + default: + printf("error in relocation type %x\n",r->r_type); + print_reloc(r); + exit(10); + } +/* + print_reloc(r); +*/ + } +} +#endif /* ! NEED_SWAP */ +print_reloc(struct relocation_info_m88k *r) +{ + printf ("%6x:\t%4d\t%d\t%d\t%d\t%d\t%x\t", + r->r_address, + r->r_symbolnum, + r->r_pcrel, + r->r_extern, + r->r_baserel, + r->r_jmptable, + r->r_addend + ); + switch (r->r_type) { + case RELOC_LO16: + printf("lo16\n"); + break; + case RELOC_HI16: + printf("hi16\n"); + break; + case RELOC_PC16: + printf("pc16\n"); + break; + case RELOC_PC26: + printf("pc26\n"); + break; + case RELOC_32: + printf("reloc32\n"); + break; + case RELOC_IW16: + printf("iw16\n"); + break; + case NO_RELOC: + printf("none\n"); + break; + case RELOC_GLOB_DAT: + printf("glob_dat\n"); + break; + case RELOC_JMP_SLOT: + printf("jmp_slot\n"); + break; + case RELOC_RELATIVE: + printf("rel\n"); + break; + } + +} diff --git a/gnu/usr.bin/ld/mvme88k/md.h b/gnu/usr.bin/ld/mvme88k/md.h new file mode 100644 index 00000000000..6e7fa1024df --- /dev/null +++ b/gnu/usr.bin/ld/mvme88k/md.h @@ -0,0 +1,263 @@ +/* + * $Id: md.h,v 1.1 1997/04/23 21:24:41 rahnds Exp $ + * - m68k dependent definitions + */ + +#if defined(CROSS_LINKER) && defined(XHOST) && XHOST==i386 +#define NEED_SWAP +#endif + +#if defined(CROSS_LINKER) +#undef MID_MACHINE +/* XXX */ +#define MID_MACHINE 151 +#endif + +#define MAX_ALIGNMENT (sizeof (double)) + +#define PAGSIZ 0x1000 +#undef __LDPGSZ +#define __LDPGSZ 0x1000 + +#define N_SET_FLAG(ex,f) N_SETMAGIC(ex,N_GETMAGIC(ex), MID_MACHINE, \ + N_GETFLAG(ex)|(f)) + +#define N_IS_DYNAMIC(ex) ((N_GETFLAG(ex) & EX_DYNAMIC)) + +#define N_BADMID(ex) \ + (N_GETMID(ex) != 0 && N_GETMID(ex) != MID_MACHINE && \ + !md_midcompat(&(ex))) + +/* + * Should be handled by a.out.h ? + */ +#define N_ADJUST(ex) (((ex).a_entry < PAGSIZ) ? -PAGSIZ : 0) +/* +#define TEXT_START(ex) (N_TXTADDR(ex) + N_ADJUST(ex)) +*/ +#define TEXT_START(ex) (N_TXTADDR(ex)) +#define DATA_START(ex) (N_DATADDR(ex) + N_ADJUST(ex)) + +#define RELOC_STATICS_THROUGH_GOT_P(r) (1) +#define JMPSLOT_NEEDS_RELOC (0) + +#define md_got_reloc(r) (0) + +#define md_get_rt_segment_addend(r,a) md_get_addend(r,a) + +/* Width of a Global Offset Table entry */ +#define GOT_ENTRY_SIZE 4 +typedef long got_t; + +typedef struct jmpslot { + u_short opcode; + u_short addr[2]; + u_short reloc_index; +#define JMPSLOT_RELOC_MASK 0xffff +} jmpslot_t; + +#if 1 /* NOT REALLY */ +#define NOP 0x4e71 +#define BSRL 0x61ff /* BSR opcode with long offset */ +#define BRAL 0x60ff /* BRA opcode with long offset */ +#define BPT 0x4e42 /* breakpoint trap: trap #2 */ +#endif + +/* m88k */ +enum reloc_type { + + RELOC_LO16, /* lo16(sym) */ + RELOC_HI16, /* hi16(sym) */ + RELOC_PC16, /* bb0, bb1, bcnd */ + RELOC_PC26, /* br, bsr */ + RELOC_32, /* jump tables, etc */ + RELOC_IW16, /* global access through linker regs 28 */ + NO_RELOC, + RELOC_GLOB_DAT, + RELOC_JMP_SLOT, + RELOC_RELATIVE +}; +#if 0 +struct relocation_info_m88k { + unsigned int r_address; /* offset in text or data segment */ + unsigned int r_symbolnum : 24, /* ordinal number of add symbol */ + r_extern : 1, /* 1 if need to add symbol to value */ + r_baserel : 1, + r_pcrel : 1, + r_jmptable : 1, + r_type : 4; + + int r_addend; +}; +#endif +struct r_relocation_info_m88k { + unsigned int r_address; /* offset in text or data segment */ + unsigned int r_type : 4, + r_jmptable : 1, + r_pcrel : 1, + r_baserel : 1, + r_extern : 1, /* 1 if need to add symbol to value */ + r_symbolnum : 24; /* ordinal number of add symbol */ + + int r_addend; +}; +#undef relocation_info +#define relocation_info relocation_info_m88k + + + + +/* + * Byte swap defs for cross linking + */ + +#if !defined(NEED_SWAP) + +#define md_swapin_exec_hdr(h) +#define md_swapout_exec_hdr(h) +#define md_swapin_symbols(s,n) +#define md_swapout_symbols(s,n) +#define md_swapin_zsymbols(s,n) +#define md_swapout_zsymbols(s,n) +#define md_swapin_reloc(r,n) md_in_reloc(r,n) +#define md_swapout_reloc(r,n) +#define md_swapin__dynamic(l) +#define md_swapout__dynamic(l) +#define md_swapin_section_dispatch_table(l) +#define md_swapout_section_dispatch_table(l) +#define md_swapin_so_debug(d) +#define md_swapout_so_debug(d) +#define md_swapin_rrs_hash(f,n) +#define md_swapout_rrs_hash(f,n) +#define md_swapin_sod(l,n) +#define md_swapout_sod(l,n) +#define md_swapout_jmpslot(j,n) +#define md_swapout_got(g,n) +#define md_swapin_ranlib_hdr(h,n) +#define md_swapout_ranlib_hdr(h,n) + +#endif /* NEED_SWAP */ + +#ifdef CROSS_LINKER + +#define get_byte(p) ( ((unsigned char *)(p))[0] ) + +#define get_short(p) ( ( ((unsigned char *)(p))[0] << 8) | \ + ( ((unsigned char *)(p))[1] ) \ + ) +#define get_long(p) ( ( ((unsigned char *)(p))[0] << 24) | \ + ( ((unsigned char *)(p))[1] << 16) | \ + ( ((unsigned char *)(p))[2] << 8 ) | \ + ( ((unsigned char *)(p))[3] ) \ + ) + +#define put_byte(p, v) { ((unsigned char *)(p))[0] = ((unsigned long)(v)); } + +#define put_short(p, v) { ((unsigned char *)(p))[0] = \ + ((((unsigned long)(v)) >> 8) & 0xff); \ + ((unsigned char *)(p))[1] = \ + ((((unsigned long)(v)) ) & 0xff); } + +#define put_long(p, v) { ((unsigned char *)(p))[0] = \ + ((((unsigned long)(v)) >> 24) & 0xff); \ + ((unsigned char *)(p))[1] = \ + ((((unsigned long)(v)) >> 16) & 0xff); \ + ((unsigned char *)(p))[2] = \ + ((((unsigned long)(v)) >> 8) & 0xff); \ + ((unsigned char *)(p))[3] = \ + ((((unsigned long)(v)) ) & 0xff); } +#define put_b26(p, v) { ((unsigned char *)(p))[0] = \ + ((((unsigned long)(v)) >> 24) & 0x03 | \ + ((unsigned char *)(p))[0] & 0xfc); \ + ((unsigned char *)(p))[1] = \ + ((((unsigned long)(v)) >> 16) & 0xff); \ + ((unsigned char *)(p))[2] = \ + ((((unsigned long)(v)) >> 8) & 0xff); \ + ((unsigned char *)(p))[3] = \ + ((((unsigned long)(v)) ) & 0xff); } + + +#ifdef NEED_SWAP + +/* Define IO byte swapping routines */ + +void md_swapin_exec_hdr __P((struct exec *)); +void md_swapout_exec_hdr __P((struct exec *)); +void md_swapin_reloc __P((struct relocation_info *, int)); +void md_swapout_reloc __P((struct relocation_info *, int)); +void md_swapout_jmpslot __P((jmpslot_t *, int)); + +#define md_swapin_symbols(s,n) swap_symbols(s,n) +#define md_swapout_symbols(s,n) swap_symbols(s,n) +#define md_swapin_zsymbols(s,n) swap_zsymbols(s,n) +#define md_swapout_zsymbols(s,n) swap_zsymbols(s,n) +#define md_swapin__dynamic(l) swap__dynamic(l) +#define md_swapout__dynamic(l) swap__dynamic(l) +#define md_swapin_section_dispatch_table(l) swap_section_dispatch_table(l) +#define md_swapout_section_dispatch_table(l) swap_section_dispatch_table(l) +#define md_swapin_so_debug(d) swap_so_debug(d) +#define md_swapout_so_debug(d) swap_so_debug(d) +#define md_swapin_rrs_hash(f,n) swap_rrs_hash(f,n) +#define md_swapout_rrs_hash(f,n) swap_rrs_hash(f,n) +#define md_swapin_sod(l,n) swapin_sod(l,n) +#define md_swapout_sod(l,n) swapout_sod(l,n) +#define md_swapout_got(g,n) swap_longs((long*)(g),n) +#define md_swapin_ranlib_hdr(h,n) swap_ranlib_hdr(h,n) +#define md_swapout_ranlib_hdr(h,n) swap_ranlib_hdr(h,n) + +#define md_swap_short(x) ( (((x) >> 8) & 0xff) | (((x) & 0xff) << 8) ) + +#define md_swap_long(x) ( (((x) >> 24) & 0xff ) | (((x) >> 8 ) & 0xff00 ) | \ + (((x) << 8 ) & 0xff0000) | (((x) << 24) & 0xff000000)) + +#else /* We need not swap, but must pay attention to alignment: */ + +#define md_swap_short(x) (x) +#define md_swap_long(x) (x) + +#endif /* NEED_SWAP */ + +#else /* Not a cross linker: use native */ + +#define md_swap_short(x) (x) +#define md_swap_long(x) (x) + +#define get_byte(where) (*(char *)(where)) +#define get_short(where) (*(short *)(where)) +#define get_long(where) (*(long *)(where)) + +#define put_byte(where,what) (*(char *)(where) = (what)) +#define put_short(where,what) (*(short *)(where) = (what)) +#define put_long(where,what) (*(long *)(where) = (what)) +#define put_b26(where, what) (*(long *)(where) = ((*(long *)(where))\ + & ~0x03ffffff) | ((what) & 0x03ffffff)) + +#endif /* CROSS_LINKER */ + +#if 0 +#define RELOC_ADDRESS(r) ((r)->r_address) +#define RELOC_EXTERN_P(r) ((r)->r_extern) +#define RELOC_TYPE(r) ((r)->r_symbolnum) +#define RELOC_SYMBOL(r) ((r)->r_symbolnum) +#define RELOC_MEMORY_SUB_P(r) 0 +#define RELOC_MEMORY_ADD_P(r) 1 +#undef RELOC_ADD_EXTRA +#define RELOC_PCREL_P(r) ((r)->r_pcrel) +#define RELOC_VALUE_RIGHTSHIFT(r) 0 +#if defined(RTLD) && defined(SUN_COMPAT) +#define RELOC_TARGET_SIZE(r) (2) /* !!!!! Sun BUG compatible */ +#else +#define RELOC_TARGET_SIZE(r) ((r)->r_length) +#endif +#define RELOC_TARGET_BITPOS(r) 0 +#define RELOC_TARGET_BITSIZE(r) 32 + +#define RELOC_JMPTAB_P(r) ((r)->r_jmptable) +#define RELOC_BASEREL_P(r) ((r)->r_baserel) +#define RELOC_RELATIVE_P(r) ((r)->r_relative) +#define RELOC_COPY_P(r) ((r)->r_copy) +#define RELOC_LAZY_P(r) ((r)->r_jmptable) + +#define CHECK_GOT_RELOC(r) (0) +#endif +