gas/config/tc-pj.c

   1 /* tc-pj.c -- Assemble code for Pico Java
   2    Copyright (C) 1999-2018 Free Software Foundation, Inc.
   3
   4    This file is part of GAS, the GNU Assembler.
   5
   6    GAS is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    GAS is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GAS; see the file COPYING.  If not, write to
  18    the Free Software Foundation, 51 Franklin Street - Fifth Floor,
  19    Boston, MA 02110-1301, USA.  */
  20
  21 /* Contributed by Steve Chamberlain of Transmeta <sac@pobox.com>.  */
  22
  23 #include "as.h"
  24 #include "safe-ctype.h"
  25 #include "opcode/pj.h"
  26
  27 extern const pj_opc_info_t pj_opc_info[512];
  28
  29 const char comment_chars[]        = "!/";
  30 const char line_separator_chars[] = ";";
  31 const char line_comment_chars[]   = "/!#";
  32
  33 static int pending_reloc;
  34 static struct hash_control *opcode_hash_control;
  35
  36 static void
  37 little (int ignore ATTRIBUTE_UNUSED)
  38 {
  39   target_big_endian = 0;
  40 }
  41
  42 static void
  43 big (int ignore ATTRIBUTE_UNUSED)
  44 {
  45   target_big_endian = 1;
  46 }
  47
  48 const pseudo_typeS md_pseudo_table[] =
  49 {
  50   {"ml",    little, 0},
  51   {"mb",    big,    0},
  52   {0, 0, 0}
  53 };
  54
  55 const char FLT_CHARS[] = "rRsSfFdDxXpP";
  56 const char EXP_CHARS[] = "eE";
  57
  58 void
  59 md_operand (expressionS *op)
  60 {
  61   if (strncmp (input_line_pointer, "%hi16", 5) == 0)
  62     {
  63       if (pending_reloc)
  64         as_bad (_("confusing relocation expressions"));
  65       pending_reloc = BFD_RELOC_PJ_CODE_HI16;
  66       input_line_pointer += 5;
  67       expression (op);
  68     }
  69
  70   if (strncmp (input_line_pointer, "%lo16", 5) == 0)
  71     {
  72       if (pending_reloc)
  73         as_bad (_("confusing relocation expressions"));
  74       pending_reloc = BFD_RELOC_PJ_CODE_LO16;
  75       input_line_pointer += 5;
  76       expression (op);
  77     }
  78 }
  79
  80 /* Parse an expression and then restore the input line pointer.  */
  81
  82 static char *
  83 parse_exp_save_ilp (char *s, expressionS *op)
  84 {
  85   char *save = input_line_pointer;
  86
  87   input_line_pointer = s;
  88   expression (op);
  89   s = input_line_pointer;
  90   input_line_pointer = save;
  91   return s;
  92 }
  93
  94 /* This is called by emit_expr via TC_CONS_FIX_NEW when creating a
  95    reloc for a cons.  We could use the definition there, except that
  96    we want to handle magic pending reloc expressions specially.  */
  97
  98 void
  99 pj_cons_fix_new_pj (fragS *frag, int where, int nbytes, expressionS *exp,
 100                     bfd_reloc_code_real_type r ATTRIBUTE_UNUSED)
 101 {
 102   static int rv[5][2] =
 103   { { 0, 0 },
 104     { BFD_RELOC_8, BFD_RELOC_8 },
 105     { BFD_RELOC_PJ_CODE_DIR16, BFD_RELOC_16 },
 106     { 0, 0 },
 107     { BFD_RELOC_PJ_CODE_DIR32, BFD_RELOC_32 }};
 108
 109   fix_new_exp (frag, where, nbytes, exp, 0,
 110                pending_reloc ? pending_reloc
 111                : rv[nbytes][(now_seg->flags & SEC_CODE) ? 0 : 1]);
 112
 113   pending_reloc = 0;
 114 }
 115
 116 /* Turn a reloc description character from the pj-opc.h table into
 117    code which BFD can handle.  */
 118
 119 static int
 120 c_to_r (int x)
 121 {
 122   switch (x)
 123     {
 124     case O_R8:
 125       return BFD_RELOC_8_PCREL;
 126     case O_U8:
 127     case O_8:
 128       return BFD_RELOC_8;
 129     case O_R16:
 130       return BFD_RELOC_PJ_CODE_REL16;
 131     case O_U16:
 132     case O_16:
 133       return BFD_RELOC_PJ_CODE_DIR16;
 134     case O_R32:
 135       return BFD_RELOC_PJ_CODE_REL32;
 136     case O_32:
 137       return BFD_RELOC_PJ_CODE_DIR32;
 138     }
 139   abort ();
 140   return 0;
 141 }
 142
 143 /* Handler for the ipush fake opcode,
 144    turns ipush <foo> into sipush lo16<foo>, sethi hi16<foo>.  */
 145
 146 static void
 147 ipush_code (pj_opc_info_t *opcode ATTRIBUTE_UNUSED, char *str)
 148 {
 149   char *b = frag_more (6);
 150   expressionS arg;
 151
 152   b[0] = 0x11;
 153   b[3] = 0xed;
 154   parse_exp_save_ilp (str + 1, &arg);
 155   if (pending_reloc)
 156     {
 157       as_bad (_("can't have relocation for ipush"));
 158       pending_reloc = 0;
 159     }
 160
 161   fix_new_exp (frag_now, b - frag_now->fr_literal + 1, 2,
 162                &arg, 0, BFD_RELOC_PJ_CODE_DIR16);
 163   fix_new_exp (frag_now, b - frag_now->fr_literal + 4, 2,
 164                &arg, 0, BFD_RELOC_PJ_CODE_HI16);
 165 }
 166
 167 /* Insert names into the opcode table which are really mini macros,
 168    not opcodes.  The fakeness is indicated with an opcode of -1.  */
 169
 170 static void
 171 fake_opcode (const char *name,
 172              void (*func) (struct pj_opc_info_t *, char *))
 173 {
 174   pj_opc_info_t * fake = XNEW (pj_opc_info_t);
 175
 176   fake->opcode = -1;
 177   fake->opcode_next = -1;
 178   fake->u.func = func;
 179   hash_insert (opcode_hash_control, name, (char *) fake);
 180 }
 181
 182 /* Enter another entry into the opcode hash table so the same opcode
 183    can have another name.  */
 184
 185 static void
 186 alias (const char *new_name, const char *old)
 187 {
 188   hash_insert (opcode_hash_control, new_name,
 189                (char *) hash_find (opcode_hash_control, old));
 190 }
 191
 192 /* This function is called once, at assembler startup time.  It sets
 193    up the hash table with all the opcodes in it, and also initializes
 194    some aliases for compatibility with other assemblers.  */
 195
 196 void
 197 md_begin (void)
 198 {
 199   const pj_opc_info_t *opcode;
 200   opcode_hash_control = hash_new ();
 201
 202   /* Insert names into hash table.  */
 203   for (opcode = pj_opc_info; opcode->u.name; opcode++)
 204     hash_insert (opcode_hash_control, opcode->u.name, (char *) opcode);
 205
 206   /* Insert the only fake opcode.  */
 207   fake_opcode ("ipush", ipush_code);
 208
 209   /* Add some aliases for opcode names.  */
 210   alias ("ifeq_s", "ifeq");
 211   alias ("ifne_s", "ifne");
 212   alias ("if_icmpge_s", "if_icmpge");
 213   alias ("if_icmpne_s", "if_icmpne");
 214   alias ("if_icmpeq_s", "if_icmpeq");
 215   alias ("if_icmpgt_s", "if_icmpgt");
 216   alias ("goto_s", "goto");
 217
 218   bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0);
 219 }
 220
 221 /* This is the guts of the machine-dependent assembler.  STR points to
 222    a machine dependent instruction.  This function is supposed to emit
 223    the frags/bytes it assembles to.  */
 224
 225 void
 226 md_assemble (char *str)
 227 {
 228   char *op_start;
 229   char *op_end;
 230
 231   pj_opc_info_t *opcode;
 232   char *output;
 233   int idx = 0;
 234   char pend;
 235
 236   int nlen = 0;
 237
 238   /* Drop leading whitespace.  */
 239   while (*str == ' ')
 240     str++;
 241
 242   /* Find the op code end.  */
 243   op_start = str;
 244   for (op_end = str;
 245        *op_end && !is_end_of_line[*op_end & 0xff] && *op_end != ' ';
 246        op_end++)
 247     nlen++;
 248
 249   pend = *op_end;
 250   *op_end = 0;
 251
 252   if (nlen == 0)
 253     as_bad (_("can't find opcode "));
 254
 255   opcode = (pj_opc_info_t *) hash_find (opcode_hash_control, op_start);
 256   *op_end = pend;
 257
 258   if (opcode == NULL)
 259     {
 260       as_bad (_("unknown opcode %s"), op_start);
 261       return;
 262     }
 263
 264   dwarf2_emit_insn (0);
 265   if (opcode->opcode == -1)
 266     {
 267       /* It's a fake opcode.  Dig out the args and pretend that was
 268          what we were passed.  */
 269       (*opcode->u.func) (opcode, op_end);
 270     }
 271   else
 272     {
 273       int an;
 274
 275       output = frag_more (opcode->len);
 276       output[idx++] = opcode->opcode;
 277
 278       if (opcode->opcode_next != -1)
 279         output[idx++] = opcode->opcode_next;
 280
 281       for (an = 0; opcode->arg[an]; an++)
 282         {
 283           expressionS arg;
 284
 285           if (*op_end == ',' && an != 0)
 286             op_end++;
 287
 288           if (*op_end == 0)
 289             as_bad (_("expected expression"));
 290
 291           op_end = parse_exp_save_ilp (op_end, &arg);
 292
 293           fix_new_exp (frag_now,
 294                        output - frag_now->fr_literal + idx,
 295                        ASIZE (opcode->arg[an]),
 296                        &arg,
 297                        PCREL (opcode->arg[an]),
 298                        pending_reloc ? pending_reloc : c_to_r (opcode->arg[an]));
 299
 300           idx += ASIZE (opcode->arg[an]);
 301           pending_reloc = 0;
 302         }
 303
 304       while (ISSPACE (*op_end))
 305         op_end++;
 306
 307       if (*op_end != 0)
 308         as_warn (_("extra stuff on line ignored"));
 309
 310     }
 311
 312   if (pending_reloc)
 313     as_bad (_("Something forgot to clean up\n"));
 314 }
 315
 316 const char *
 317 md_atof (int type, char *litP, int *sizeP)
 318 {
 319   return ieee_md_atof (type, litP, sizeP, target_big_endian);
 320 }
 321 \f
 322 const char *md_shortopts = "";
 323
 324 struct option md_longopts[] =
 325 {
 326 #define OPTION_LITTLE (OPTION_MD_BASE)
 327 #define OPTION_BIG    (OPTION_LITTLE + 1)
 328
 329   {"little", no_argument, NULL, OPTION_LITTLE},
 330   {"big", no_argument, NULL, OPTION_BIG},
 331   {NULL, no_argument, NULL, 0}
 332 };
 333 size_t md_longopts_size = sizeof (md_longopts);
 334
 335 int
 336 md_parse_option (int c, const char *arg ATTRIBUTE_UNUSED)
 337 {
 338   switch (c)
 339     {
 340     case OPTION_LITTLE:
 341       little (0);
 342       break;
 343     case OPTION_BIG:
 344       big (0);
 345       break;
 346     default:
 347       return 0;
 348     }
 349   return 1;
 350 }
 351
 352 void
 353 md_show_usage (FILE *stream)
 354 {
 355   fprintf (stream, _("\
 356 PJ options:\n\
 357 -little                 generate little endian code\n\
 358 -big                    generate big endian code\n"));
 359 }
 360
 361 /* Apply a fixup to the object file.  */
 362
 363 void
 364 md_apply_fix (fixS *fixP, valueT * valP, segT seg ATTRIBUTE_UNUSED)
 365 {
 366   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
 367   long val = *valP;
 368   long max, min;
 369
 370   max = min = 0;
 371   switch (fixP->fx_r_type)
 372     {
 373     case BFD_RELOC_VTABLE_INHERIT:
 374     case BFD_RELOC_VTABLE_ENTRY:
 375       fixP->fx_done = 0;
 376       return;
 377
 378     case BFD_RELOC_PJ_CODE_REL16:
 379       if (val < -0x8000 || val >= 0x7fff)
 380         as_bad_where (fixP->fx_file, fixP->fx_line, _("pcrel too far"));
 381       buf[0] |= (val >> 8) & 0xff;
 382       buf[1] = val & 0xff;
 383       break;
 384
 385     case BFD_RELOC_PJ_CODE_HI16:
 386       *buf++ = val >> 24;
 387       *buf++ = val >> 16;
 388       fixP->fx_addnumber = val & 0xffff;
 389       break;
 390
 391     case BFD_RELOC_PJ_CODE_DIR16:
 392     case BFD_RELOC_PJ_CODE_LO16:
 393       *buf++ = val >> 8;
 394       *buf++ = val >> 0;
 395
 396       max = 0xffff;
 397       min = -0xffff;
 398       break;
 399
 400     case BFD_RELOC_8:
 401       max = 0xff;
 402       min = -0xff;
 403       *buf++ = val;
 404       break;
 405
 406     case BFD_RELOC_PJ_CODE_DIR32:
 407       *buf++ = val >> 24;
 408       *buf++ = val >> 16;
 409       *buf++ = val >> 8;
 410       *buf++ = val >> 0;
 411       break;
 412
 413     case BFD_RELOC_32:
 414       if (target_big_endian)
 415         {
 416           *buf++ = val >> 24;
 417           *buf++ = val >> 16;
 418           *buf++ = val >> 8;
 419           *buf++ = val >> 0;
 420         }
 421       else
 422         {
 423           *buf++ = val >> 0;
 424           *buf++ = val >> 8;
 425           *buf++ = val >> 16;
 426           *buf++ = val >> 24;
 427         }
 428       break;
 429
 430     case BFD_RELOC_16:
 431       if (target_big_endian)
 432         {
 433           *buf++ = val >> 8;
 434           *buf++ = val >> 0;
 435         }
 436       else
 437         {
 438           *buf++ = val >> 0;
 439           *buf++ = val >> 8;
 440         }
 441       break;
 442
 443     case BFD_RELOC_PJ_CODE_REL32:
 444       fixP->fx_done = 0;
 445       return;
 446
 447     default:
 448       abort ();
 449     }
 450
 451   if (max != 0 && (val < min || val > max))
 452     as_bad_where (fixP->fx_file, fixP->fx_line, _("offset out of range"));
 453
 454   if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
 455     fixP->fx_done = 1;
 456 }
 457
 458 /* Put number into target byte order.  Always put values in an
 459    executable section into big endian order.  */
 460
 461 void
 462 md_number_to_chars (char *ptr, valueT use, int nbytes)
 463 {
 464   if (target_big_endian || now_seg->flags & SEC_CODE)
 465     number_to_chars_bigendian (ptr, use, nbytes);
 466   else
 467     number_to_chars_littleendian (ptr, use, nbytes);
 468 }
 469
 470 /* Translate internal representation of relocation info to BFD target
 471    format.  */
 472
 473 arelent *
 474 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
 475 {
 476   arelent *rel;
 477   bfd_reloc_code_real_type r_type;
 478
 479   rel = XNEW (arelent);
 480   rel->sym_ptr_ptr = XNEW (asymbol *);
 481   *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
 482   rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
 483
 484   r_type = fixp->fx_r_type;
 485   rel->addend = fixp->fx_addnumber;
 486   rel->howto = bfd_reloc_type_lookup (stdoutput, r_type);
 487
 488   if (rel->howto == NULL)
 489     {
 490       as_bad_where (fixp->fx_file, fixp->fx_line,
 491                     _("Cannot represent relocation type %s"),
 492                     bfd_get_reloc_code_name (r_type));
 493       /* Set howto to a garbage value so that we can keep going.  */
 494       rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
 495       gas_assert (rel->howto != NULL);
 496     }
 497
 498   return rel;
 499 }