X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gas%2Fconfig%2Ftc-pj.c;h=752392b6e3983a8c225821a4970d914fbe166f6e;hb=bd920864f3dc2cad376989a642ab774aef6b2fce;hp=4f803095b2198a659fb5a90e434a0ba60fe6b7ca;hpb=041dd5a9f4231569f5526d0bd192521a108e7286;p=deliverable%2Fbinutils-gdb.git diff --git a/gas/config/tc-pj.c b/gas/config/tc-pj.c index 4f803095b2..752392b6e3 100644 --- a/gas/config/tc-pj.c +++ b/gas/config/tc-pj.c @@ -1,12 +1,11 @@ -/*- - tc-pj.c -- Assemble code for Pico Java - Copyright (C) 1999 Free Software Foundation. +/* tc-pj.c -- Assemble code for Pico Java + Copyright (C) 1999-2020 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) + the Free Software Foundation; either version 3, or (at your option) any later version. GAS is distributed in the hope that it will be useful, @@ -16,80 +15,75 @@ 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, 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + the Free Software Foundation, 51 Franklin Street - Fifth Floor, + Boston, MA 02110-1301, USA. */ -/* Contributed by Steve Chamberlain of Transmeta, sac@pobox.com */ +/* Contributed by Steve Chamberlain of Transmeta . */ #include "as.h" +#include "safe-ctype.h" #include "opcode/pj.h" - extern const pj_opc_info_t pj_opc_info[512]; -const char comment_chars[] = "!/"; +const char comment_chars[] = "!/"; const char line_separator_chars[] = ";"; -const char line_comment_chars[] = "/!#"; +const char line_comment_chars[] = "/!#"; static int pending_reloc; static struct hash_control *opcode_hash_control; - static void -little (ignore) - int ignore ATTRIBUTE_UNUSED; +little (int ignore ATTRIBUTE_UNUSED) { target_big_endian = 0; } static void -big (ignore) - int ignore ATTRIBUTE_UNUSED; +big (int ignore ATTRIBUTE_UNUSED) { target_big_endian = 1; } - -const pseudo_typeS md_pseudo_table[] = { +const pseudo_typeS md_pseudo_table[] = +{ {"ml", little, 0}, {"mb", big, 0}, {0, 0, 0} }; - const char FLT_CHARS[] = "rRsSfFdDxXpP"; const char EXP_CHARS[] = "eE"; void -md_operand (op) - expressionS *op; +md_operand (expressionS *op) { if (strncmp (input_line_pointer, "%hi16", 5) == 0) { if (pending_reloc) - as_bad (_ ("confusing relocation expressions")); + as_bad (_("confusing relocation expressions")); pending_reloc = BFD_RELOC_PJ_CODE_HI16; input_line_pointer += 5; expression (op); } + if (strncmp (input_line_pointer, "%lo16", 5) == 0) { if (pending_reloc) - as_bad (_ ("confusing relocation expressions")); + as_bad (_("confusing relocation expressions")); pending_reloc = BFD_RELOC_PJ_CODE_LO16; input_line_pointer += 5; expression (op); } } -/* Parse an expression and then restore the input line pointer. */ +/* Parse an expression and then restore the input line pointer. */ static char * -parse_exp_save_ilp (s, op) - char *s; - expressionS *op; +parse_exp_save_ilp (char *s, expressionS *op) { char *save = input_line_pointer; + input_line_pointer = s; expression (op); s = input_line_pointer; @@ -102,33 +96,28 @@ parse_exp_save_ilp (s, op) we want to handle magic pending reloc expressions specially. */ void -pj_cons_fix_new_pj (frag, where, nbytes, exp) - fragS *frag; - int where; - int nbytes; - expressionS *exp; +pj_cons_fix_new_pj (fragS *frag, int where, int nbytes, expressionS *exp, + bfd_reloc_code_real_type r ATTRIBUTE_UNUSED) { - static int rv[5][2] = + static int rv[5][2] = { { 0, 0 }, { BFD_RELOC_8, BFD_RELOC_8 }, { BFD_RELOC_PJ_CODE_DIR16, BFD_RELOC_16 }, { 0, 0 }, { BFD_RELOC_PJ_CODE_DIR32, BFD_RELOC_32 }}; - fix_new_exp (frag, where, nbytes, exp, 0, + fix_new_exp (frag, where, nbytes, exp, 0, pending_reloc ? pending_reloc - : rv [nbytes][(now_seg->flags & SEC_CODE) ? 0 : 1]); + : rv[nbytes][(now_seg->flags & SEC_CODE) ? 0 : 1]); pending_reloc = 0; } - /* Turn a reloc description character from the pj-opc.h table into - code which BFD can handle. */ + code which BFD can handle. */ static int -c_to_r (x) - char x; +c_to_r (int x) { switch (x) { @@ -151,80 +140,73 @@ c_to_r (x) return 0; } - - - /* Handler for the ipush fake opcode, - turns ipush into sipush lo16, sethi hi16. */ + turns ipush into sipush lo16, sethi hi16. */ static void -ipush_code (opcode, str) - pj_opc_info_t *opcode ATTRIBUTE_UNUSED; - char *str; +ipush_code (pj_opc_info_t *opcode ATTRIBUTE_UNUSED, char *str) { - int mod = 0; char *b = frag_more (6); expressionS arg; + b[0] = 0x11; b[3] = 0xed; - parse_exp_save_ilp (str + 1, &arg, &mod); - if (mod) - as_bad (_ ("can't have relocation for ipush")); - + parse_exp_save_ilp (str + 1, &arg); + if (pending_reloc) + { + as_bad (_("can't have relocation for ipush")); + pending_reloc = 0; + } - fix_new_exp (frag_now, b - frag_now->fr_literal + 1, 2, - &arg, 0, BFD_RELOC_PJ_CODE_DIR16); + fix_new_exp (frag_now, b - frag_now->fr_literal + 1, 2, + &arg, 0, BFD_RELOC_PJ_CODE_DIR16); fix_new_exp (frag_now, b - frag_now->fr_literal + 4, 2, - &arg, 0, BFD_RELOC_PJ_CODE_HI16); + &arg, 0, BFD_RELOC_PJ_CODE_HI16); } /* Insert names into the opcode table which are really mini macros, - not opcodes. The fakeness is inidicated with an opcode of -1. */ + not opcodes. The fakeness is indicated with an opcode of -1. */ static void - fake_opcode (name, func) const char * - name; - void (*func) (); +fake_opcode (const char *name, + void (*func) (struct pj_opc_info_t *, char *)) { - pj_opc_info_t *fake = (pj_opc_info_t *) xmalloc (sizeof (pj_opc_info_t)); + pj_opc_info_t * fake = XNEW (pj_opc_info_t); fake->opcode = -1; fake->opcode_next = -1; - fake->name = (const char *) func; + fake->u.func = func; hash_insert (opcode_hash_control, name, (char *) fake); } - /* Enter another entry into the opcode hash table so the same opcode - can have another name. */ + can have another name. */ + static void - alias (new, old) const char * - new; - const char *old; +alias (const char *new_name, const char *old) { - hash_insert (opcode_hash_control, new, + hash_insert (opcode_hash_control, new_name, (char *) hash_find (opcode_hash_control, old)); } - /* This function is called once, at assembler startup time. It sets up the hash table with all the opcodes in it, and also initializes - some aliases for compatibility with other assemblers. */ + some aliases for compatibility with other assemblers. */ void -md_begin () +md_begin (void) { const pj_opc_info_t *opcode; opcode_hash_control = hash_new (); - /* Insert names into hash table */ - for (opcode = pj_opc_info; opcode->name; opcode++) - hash_insert (opcode_hash_control, opcode->name, (char *) opcode); + /* Insert names into hash table. */ + for (opcode = pj_opc_info; opcode->u.name; opcode++) + hash_insert (opcode_hash_control, opcode->u.name, (char *) opcode); - /* Insert the only fake opcode. */ + /* Insert the only fake opcode. */ fake_opcode ("ipush", ipush_code); - /* Add some aliases for opcode names. */ + /* Add some aliases for opcode names. */ alias ("ifeq_s", "ifeq"); alias ("ifne_s", "ifne"); alias ("if_icmpge_s", "if_icmpge"); @@ -236,19 +218,16 @@ md_begin () bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0); } -/* This is the guts of the machine-dependent assembler. STR points to a - machine dependent instruction. This function is supposed to emit - the frags/bytes it assembles to. - */ +/* This is the guts of the machine-dependent assembler. STR points to + a machine dependent instruction. This function is supposed to emit + the frags/bytes it assembles to. */ void -md_assemble (str) - char *str; +md_assemble (char *str) { - unsigned char *op_start; - unsigned char *op_end; + char *op_start; + char *op_end; - // pj_operan_info operand[3]; pj_opc_info_t *opcode; char *output; int idx = 0; @@ -256,38 +235,38 @@ md_assemble (str) int nlen = 0; - /* Drop leading whitespace */ + /* Drop leading whitespace. */ while (*str == ' ') str++; - /* find the op code end */ - for (op_start = op_end = (unsigned char *) (str); - *op_end && !is_end_of_line[*op_end] && *op_end != ' '; - op_end++) + /* Find the op code end. */ + op_start = str; + for (op_end = str; + *op_end && !is_end_of_line[*op_end & 0xff] && *op_end != ' '; + op_end++) nlen++; pend = *op_end; *op_end = 0; if (nlen == 0) - { - as_bad (_ ("can't find opcode ")); - } + as_bad (_("can't find opcode ")); opcode = (pj_opc_info_t *) hash_find (opcode_hash_control, op_start); *op_end = pend; if (opcode == NULL) { - as_bad (_ ("unknown opcode %s"), op_start); + as_bad (_("unknown opcode %s"), op_start); return; } + dwarf2_emit_insn (0); if (opcode->opcode == -1) { - /* It's a fake opcode.. dig out the args and pretend that was - what we were passed */ - ((void (*)()) opcode->name) (opcode, op_end); + /* It's a fake opcode. Dig out the args and pretend that was + what we were passed. */ + (*opcode->u.func) (opcode, op_end); } else { @@ -307,95 +286,43 @@ md_assemble (str) op_end++; if (*op_end == 0) - as_bad ("expected expresssion"); + as_bad (_("expected expression")); op_end = parse_exp_save_ilp (op_end, &arg); - fix_new_exp (frag_now, + fix_new_exp (frag_now, output - frag_now->fr_literal + idx, ASIZE (opcode->arg[an]), &arg, - PCREL (opcode->arg[an]), + PCREL (opcode->arg[an]), pending_reloc ? pending_reloc : c_to_r (opcode->arg[an])); idx += ASIZE (opcode->arg[an]); pending_reloc = 0; } - while (isspace (*op_end)) + while (ISSPACE (*op_end)) op_end++; if (*op_end != 0) - as_warn ("extra stuff on line ignored"); + as_warn (_("extra stuff on line ignored")); } if (pending_reloc) - as_bad ("Something forgot to clean up\n"); - + as_bad (_("Something forgot to clean up\n")); } -/* 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) - int type; - char *litP; - int *sizeP; +const char * +md_atof (int type, char *litP, int *sizeP) { - int prec; - LITTLENUM_TYPE words[4]; - char *t; - int i; - - switch (type) - { - case 'f': - prec = 2; - break; - - case 'd': - prec = 4; - 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 * 2; - - if (!target_big_endian) - { - for (i = prec - 1; i >= 0; i--) - { - md_number_to_chars (litP, (valueT) words[i], 2); - litP += 2; - } - } - else - { - for (i = 0; i < prec; i++) - { - md_number_to_chars (litP, (valueT) words[i], 2); - litP += 2; - } - } - - return NULL; + return ieee_md_atof (type, litP, sizeP, target_big_endian); } +const char *md_shortopts = ""; -CONST char *md_shortopts = ""; - -struct option md_longopts[] = { - +struct option md_longopts[] = +{ #define OPTION_LITTLE (OPTION_MD_BASE) #define OPTION_BIG (OPTION_LITTLE + 1) @@ -406,17 +333,15 @@ struct option md_longopts[] = { size_t md_longopts_size = sizeof (md_longopts); int -md_parse_option (c, arg) - int c; - char *arg ATTRIBUTE_UNUSED; +md_parse_option (int c, const char *arg ATTRIBUTE_UNUSED) { switch (c) { case OPTION_LITTLE: - little (); + little (0); break; case OPTION_BIG: - big (); + big (0); break; default: return 0; @@ -425,51 +350,34 @@ md_parse_option (c, arg) } void -md_show_usage (stream) - FILE *stream; +md_show_usage (FILE *stream) { - fprintf (stream, _ ("\ + fprintf (stream, _("\ PJ options:\n\ -little generate little endian code\n\ -big generate big endian code\n")); } - - /* Apply a fixup to the object file. */ - -int -md_apply_fix (fixP, valp) - fixS *fixP; - valueT *valp; +void +md_apply_fix (fixS *fixP, valueT * valP, segT seg ATTRIBUTE_UNUSED) { char *buf = fixP->fx_where + fixP->fx_frag->fr_literal; - long val = *valp; + long val = *valP; long max, min; - int shift; - - - /* adjust_reloc_syms won't convert a reloc against a weak symbol - into a reloc against a section, but bfd_install_relocation will - screw up if the symbol is defined, so we have to adjust val here - to avoid the screw up later. */ - - if (fixP->fx_addsy != NULL && S_IS_WEAK (fixP->fx_addsy)) - val -= S_GET_VALUE (fixP->fx_addsy); max = min = 0; - shift = 0; switch (fixP->fx_r_type) { case BFD_RELOC_VTABLE_INHERIT: case BFD_RELOC_VTABLE_ENTRY: fixP->fx_done = 0; - return 0; + return; case BFD_RELOC_PJ_CODE_REL16: if (val < -0x8000 || val >= 0x7fff) - as_bad_where (fixP->fx_file, fixP->fx_line, _ ("pcrel too far")); + as_bad_where (fixP->fx_file, fixP->fx_line, _("pcrel too far")); buf[0] |= (val >> 8) & 0xff; buf[1] = val & 0xff; break; @@ -510,7 +418,7 @@ md_apply_fix (fixP, valp) *buf++ = val >> 8; *buf++ = val >> 0; } - else + else { *buf++ = val >> 0; *buf++ = val >> 8; @@ -532,25 +440,26 @@ md_apply_fix (fixP, valp) } break; + case BFD_RELOC_PJ_CODE_REL32: + fixP->fx_done = 0; + return; default: abort (); } if (max != 0 && (val < min || val > max)) - as_bad_where (fixP->fx_file, fixP->fx_line, _ ("offset out of range")); + as_bad_where (fixP->fx_file, fixP->fx_line, _("offset out of range")); - return 0; + if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0) + fixP->fx_done = 1; } /* Put number into target byte order. Always put values in an - executable section into big endian order. */ + executable section into big endian order. */ void -md_number_to_chars (ptr, use, nbytes) - char *ptr; - valueT use; - int nbytes; +md_number_to_chars (char *ptr, valueT use, int nbytes) { if (target_big_endian || now_seg->flags & SEC_CODE) number_to_chars_bigendian (ptr, use, nbytes); @@ -558,21 +467,17 @@ md_number_to_chars (ptr, use, nbytes) number_to_chars_littleendian (ptr, use, nbytes); } - - /* Translate internal representation of relocation info to BFD target - format. */ + format. */ arelent * -tc_gen_reloc (section, fixp) - asection *section ATTRIBUTE_UNUSED; - fixS *fixp; +tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp) { arelent *rel; bfd_reloc_code_real_type r_type; - rel = (arelent *) xmalloc (sizeof (arelent)); - rel->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); + rel = XNEW (arelent); + rel->sym_ptr_ptr = XNEW (asymbol *); *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy); rel->address = fixp->fx_frag->fr_address + fixp->fx_where; @@ -583,11 +488,11 @@ tc_gen_reloc (section, fixp) if (rel->howto == NULL) { as_bad_where (fixp->fx_file, fixp->fx_line, - _ ("Cannot represent relocation type %s"), + _("Cannot represent relocation type %s"), bfd_get_reloc_code_name (r_type)); /* Set howto to a garbage value so that we can keep going. */ rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32); - assert (rel->howto != NULL); + gas_assert (rel->howto != NULL); } return rel;