gas/config/tc-moxie.c

   1 /* tc-moxie.c -- Assemble code for moxie
   2    Copyright 2009
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GAS, the GNU Assembler.
   6
   7    GAS is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3, or (at your option)
  10    any later version.
  11
  12    GAS is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GAS; see the file COPYING.  If not, write to
  19    the Free Software Foundation, 51 Franklin Street - Fifth Floor,
  20    Boston, MA 02110-1301, USA.  */
  21
  22 /* Contributed by Anthony Green <green@moxielogic.com>.  */
  23
  24 #include "as.h"
  25 #include "safe-ctype.h"
  26 #include "opcode/moxie.h"
  27 #include "elf/moxie.h"
  28
  29 extern const moxie_opc_info_t moxie_opc_info[128];
  30
  31 const char comment_chars[]        = "#";
  32 const char line_separator_chars[] = ";";
  33 const char line_comment_chars[]   = "#";
  34
  35 static int pending_reloc;
  36 static struct hash_control *opcode_hash_control;
  37
  38 const pseudo_typeS md_pseudo_table[] =
  39 {
  40   {0, 0, 0}
  41 };
  42
  43 const char FLT_CHARS[] = "rRsSfFdDxXpP";
  44 const char EXP_CHARS[] = "eE";
  45
  46 static int md_chars_to_number (char *val, int n);
  47
  48 void
  49 md_operand (expressionS *op __attribute__((unused)))
  50 {
  51   /* Empty for now. */
  52 }
  53
  54 /* This function is called once, at assembler startup time.  It sets
  55    up the hash table with all the opcodes in it, and also initializes
  56    some aliases for compatibility with other assemblers.  */
  57
  58 void
  59 md_begin (void)
  60 {
  61   int count;
  62   const moxie_opc_info_t *opcode;
  63   opcode_hash_control = hash_new ();
  64
  65   /* Insert names into hash table.  */
  66   for (count = 0, opcode = moxie_form1_opc_info; count++ < 64; opcode++)
  67     hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
  68
  69   for (count = 0, opcode = moxie_form2_opc_info; count++ < 4; opcode++)
  70     hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
  71
  72   for (count = 0, opcode = moxie_form3_opc_info; count++ < 10; opcode++)
  73     hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
  74
  75   bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0);
  76 }
  77
  78 /* Parse an expression and then restore the input line pointer.  */
  79
  80 static char *
  81 parse_exp_save_ilp (char *s, expressionS *op)
  82 {
  83   char *save = input_line_pointer;
  84
  85   input_line_pointer = s;
  86   expression (op);
  87   s = input_line_pointer;
  88   input_line_pointer = save;
  89   return s;
  90 }
  91
  92 static int
  93 parse_register_operand (char **ptr)
  94 {
  95   int reg;
  96   char *s = *ptr;
  97
  98   if (*s != '$')
  99     {
 100       as_bad (_("expecting register"));
 101       ignore_rest_of_line ();
 102       return -1;
 103     }
 104   if (s[1] == 'f' && s[2] == 'p')
 105     {
 106       *ptr += 3;
 107       return 0;
 108     }
 109   if (s[1] == 's' && s[2] == 'p')
 110     {
 111       *ptr += 3;
 112       return 1;
 113     }
 114   if (s[1] == 'r')
 115     {
 116       reg = s[2] - '0';
 117       if ((reg < 0) || (reg > 9))
 118         {
 119           as_bad (_("illegal register number"));
 120           ignore_rest_of_line ();
 121           return -1;
 122         }
 123       if (reg == 1)
 124         {
 125           int r2 = s[3] - '0';
 126           if ((r2 >= 0) && (r2 <= 3))
 127             {
 128               reg = 10 + r2;
 129               *ptr += 1;
 130             }
 131         }
 132     }
 133   else
 134     {
 135       as_bad (_("illegal register number"));
 136       ignore_rest_of_line ();
 137       return -1;
 138     }
 139
 140   *ptr += 3;
 141
 142   return reg + 2;
 143 }
 144
 145 /* This is the guts of the machine-dependent assembler.  STR points to
 146    a machine dependent instruction.  This function is supposed to emit
 147    the frags/bytes it assembles to.  */
 148
 149 void
 150 md_assemble (char *str)
 151 {
 152   char *op_start;
 153   char *op_end;
 154
 155   moxie_opc_info_t *opcode;
 156   char *p;
 157   char pend;
 158
 159   unsigned short iword = 0;
 160
 161   int nlen = 0;
 162
 163   /* Drop leading whitespace.  */
 164   while (*str == ' ')
 165     str++;
 166
 167   /* Find the op code end.  */
 168   op_start = str;
 169   for (op_end = str;
 170        *op_end && !is_end_of_line[*op_end & 0xff] && *op_end != ' ';
 171        op_end++)
 172     nlen++;
 173
 174   pend = *op_end;
 175   *op_end = 0;
 176
 177   if (nlen == 0)
 178     as_bad (_("can't find opcode "));
 179   opcode = (moxie_opc_info_t *) hash_find (opcode_hash_control, op_start);
 180   *op_end = pend;
 181
 182   if (opcode == NULL)
 183     {
 184       as_bad (_("unknown opcode %s"), op_start);
 185       return;
 186     }
 187
 188   p = frag_more (2);
 189
 190   switch (opcode->itype)
 191     {
 192     case MOXIE_F2_A8V:
 193       iword = (1<<15) | (opcode->opcode << 12);
 194       while (ISSPACE (*op_end))
 195         op_end++;
 196       {
 197         expressionS arg;
 198         int reg;
 199         reg = parse_register_operand (&op_end);
 200         iword += (reg << 8);
 201         if (*op_end != ',')
 202           as_warn (_("expecting comma delimited register operands"));
 203         op_end++;
 204         op_end = parse_exp_save_ilp (op_end, &arg);
 205         fix_new_exp (frag_now,
 206                      ((p+1) - frag_now->fr_literal),
 207                      1,
 208                      &arg,
 209                      0,
 210                      BFD_RELOC_8);
 211       }
 212       break;
 213     case MOXIE_F1_AB:
 214       iword = opcode->opcode << 8;
 215       while (ISSPACE (*op_end))
 216         op_end++;
 217       {
 218         int dest, src;
 219         dest = parse_register_operand (&op_end);
 220         if (*op_end != ',')
 221           as_warn (_("expecting comma delimited register operands"));
 222         op_end++;
 223         src  = parse_register_operand (&op_end);
 224         iword += (dest << 4) + src;
 225         while (ISSPACE (*op_end))
 226           op_end++;
 227         if (*op_end != 0)
 228           as_warn (_("extra stuff on line ignored"));
 229       }
 230       break;
 231     case MOXIE_F1_A4:
 232       iword = opcode->opcode << 8;
 233       while (ISSPACE (*op_end))
 234         op_end++;
 235       {
 236         expressionS arg;
 237         char *where;
 238         int regnum;
 239
 240         regnum = parse_register_operand (&op_end);
 241         while (ISSPACE (*op_end))
 242           op_end++;
 243
 244         iword += (regnum << 4);
 245
 246         if (*op_end != ',')
 247           {
 248             as_bad (_("expecting comma delimited operands"));
 249             ignore_rest_of_line ();
 250             return;
 251           }
 252         op_end++;
 253
 254         op_end = parse_exp_save_ilp (op_end, &arg);
 255         where = frag_more (4);
 256         fix_new_exp (frag_now,
 257                      (where - frag_now->fr_literal),
 258                      4,
 259                      &arg,
 260                      0,
 261                      BFD_RELOC_32);
 262       }
 263       break;
 264     case MOXIE_F1_M:
 265     case MOXIE_F1_4:
 266       iword = opcode->opcode << 8;
 267       while (ISSPACE (*op_end))
 268         op_end++;
 269       {
 270         expressionS arg;
 271         char *where;
 272
 273         op_end = parse_exp_save_ilp (op_end, &arg);
 274         where = frag_more (4);
 275         fix_new_exp (frag_now,
 276                      (where - frag_now->fr_literal),
 277                      4,
 278                      &arg,
 279                      0,
 280                      BFD_RELOC_32);
 281       }
 282       break;
 283     case MOXIE_F1_NARG:
 284       iword = opcode->opcode << 8;
 285       while (ISSPACE (*op_end))
 286         op_end++;
 287       if (*op_end != 0)
 288         as_warn (_("extra stuff on line ignored"));
 289       break;
 290     case MOXIE_F1_A:
 291       iword = opcode->opcode << 8;
 292       while (ISSPACE (*op_end))
 293         op_end++;
 294       {
 295         int reg;
 296         reg = parse_register_operand (&op_end);
 297         while (ISSPACE (*op_end))
 298           op_end++;
 299         if (*op_end != 0)
 300           as_warn (_("extra stuff on line ignored"));
 301         iword += (reg << 4);
 302       }
 303       break;
 304     case MOXIE_F1_ABi:
 305       iword = opcode->opcode << 8;
 306       while (ISSPACE (*op_end))
 307         op_end++;
 308       {
 309         int a, b;
 310         a = parse_register_operand (&op_end);
 311         if (*op_end != ',')
 312           as_warn (_("expecting comma delimited register operands"));
 313         op_end++;
 314         if (*op_end != '(')
 315           {
 316             as_bad (_("expecting indirect register `($rA)'"));
 317             ignore_rest_of_line ();
 318             return;
 319           }
 320         op_end++;
 321         b = parse_register_operand (&op_end);
 322         if (*op_end != ')')
 323           {
 324             as_bad (_("missing closing parenthesis"));
 325             ignore_rest_of_line ();
 326             return;
 327           }
 328         op_end++;
 329         iword += (a << 4) + b;
 330         while (ISSPACE (*op_end))
 331           op_end++;
 332         if (*op_end != 0)
 333           as_warn (_("extra stuff on line ignored"));
 334       }
 335       break;
 336     case MOXIE_F1_AiB:
 337       iword = opcode->opcode << 8;
 338       while (ISSPACE (*op_end))
 339         op_end++;
 340       {
 341         int a, b;
 342         if (*op_end != '(')
 343           {
 344             as_bad (_("expecting indirect register `($rA)'"));
 345             ignore_rest_of_line ();
 346             return;
 347           }
 348         op_end++;
 349         a = parse_register_operand (&op_end);
 350         if (*op_end != ')')
 351           {
 352             as_bad (_("missing closing parenthesis"));
 353             ignore_rest_of_line ();
 354             return;
 355           }
 356         op_end++;
 357         if (*op_end != ',')
 358           as_warn (_("expecting comma delimited register operands"));
 359         op_end++;
 360         b = parse_register_operand (&op_end);
 361         iword += (a << 4) + b;
 362         while (ISSPACE (*op_end))
 363           op_end++;
 364         if (*op_end != 0)
 365           as_warn (_("extra stuff on line ignored"));
 366       }
 367       break;
 368     case MOXIE_F1_4A:
 369       iword = opcode->opcode << 8;
 370       while (ISSPACE (*op_end))
 371         op_end++;
 372       {
 373         expressionS arg;
 374         char *where;
 375         int a;
 376
 377         op_end = parse_exp_save_ilp (op_end, &arg);
 378         where = frag_more (4);
 379         fix_new_exp (frag_now,
 380                      (where - frag_now->fr_literal),
 381                      4,
 382                      &arg,
 383                      0,
 384                      BFD_RELOC_32);
 385
 386         if (*op_end != ',')
 387           {
 388             as_bad (_("expecting comma delimited operands"));
 389             ignore_rest_of_line ();
 390             return;
 391           }
 392         op_end++;
 393
 394         a = parse_register_operand (&op_end);
 395         while (ISSPACE (*op_end))
 396           op_end++;
 397         if (*op_end != 0)
 398           as_warn (_("extra stuff on line ignored"));
 399
 400         iword += (a << 4);
 401       }
 402       break;
 403     case MOXIE_F1_ABi4:
 404       iword = opcode->opcode << 8;
 405       while (ISSPACE (*op_end))
 406         op_end++;
 407       {
 408         expressionS arg;
 409         char *offset;
 410         int a, b;
 411
 412         a = parse_register_operand (&op_end);
 413         while (ISSPACE (*op_end))
 414           op_end++;
 415
 416         if (*op_end != ',')
 417           {
 418             as_bad (_("expecting comma delimited operands"));
 419             ignore_rest_of_line ();
 420             return;
 421           }
 422         op_end++;
 423
 424         op_end = parse_exp_save_ilp (op_end, &arg);
 425         offset = frag_more (4);
 426         fix_new_exp (frag_now,
 427                      (offset - frag_now->fr_literal),
 428                      4,
 429                      &arg,
 430                      0,
 431                      BFD_RELOC_32);
 432
 433         if (*op_end != '(')
 434           {
 435             as_bad (_("expecting indirect register `($rX)'"));
 436             ignore_rest_of_line ();
 437             return;
 438           }
 439         op_end++;
 440         b = parse_register_operand (&op_end);
 441         if (*op_end != ')')
 442           {
 443             as_bad (_("missing closing parenthesis"));
 444             ignore_rest_of_line ();
 445             return;
 446           }
 447         op_end++;
 448
 449         while (ISSPACE (*op_end))
 450           op_end++;
 451         if (*op_end != 0)
 452           as_warn (_("extra stuff on line ignored"));
 453
 454         iword += (a << 4) + b;
 455       }
 456       break;
 457     case MOXIE_F1_AiB4:
 458       iword = opcode->opcode << 8;
 459       while (ISSPACE (*op_end))
 460         op_end++;
 461       {
 462         expressionS arg;
 463         char *offset;
 464         int a, b;
 465
 466         op_end = parse_exp_save_ilp (op_end, &arg);
 467         offset = frag_more (4);
 468         fix_new_exp (frag_now,
 469                      (offset - frag_now->fr_literal),
 470                      4,
 471                      &arg,
 472                      0,
 473                      BFD_RELOC_32);
 474
 475         if (*op_end != '(')
 476           {
 477             as_bad (_("expecting indirect register `($rX)'"));
 478             ignore_rest_of_line ();
 479             return;
 480           }
 481         op_end++;
 482         a = parse_register_operand (&op_end);
 483         if (*op_end != ')')
 484           {
 485             as_bad (_("missing closing parenthesis"));
 486             ignore_rest_of_line ();
 487             return;
 488           }
 489         op_end++;
 490
 491         if (*op_end != ',')
 492           {
 493             as_bad (_("expecting comma delimited operands"));
 494             ignore_rest_of_line ();
 495             return;
 496           }
 497         op_end++;
 498
 499         b = parse_register_operand (&op_end);
 500         while (ISSPACE (*op_end))
 501           op_end++;
 502
 503         while (ISSPACE (*op_end))
 504           op_end++;
 505         if (*op_end != 0)
 506           as_warn (_("extra stuff on line ignored"));
 507
 508         iword += (a << 4) + b;
 509       }
 510       break;
 511     case MOXIE_F2_NARG:
 512       iword = opcode->opcode << 12;
 513       while (ISSPACE (*op_end))
 514         op_end++;
 515       if (*op_end != 0)
 516         as_warn (_("extra stuff on line ignored"));
 517       break;
 518     case MOXIE_F3_PCREL:
 519       iword = (3<<14) | (opcode->opcode << 10);
 520       while (ISSPACE (*op_end))
 521         op_end++;
 522       {
 523         expressionS arg;
 524
 525         op_end = parse_exp_save_ilp (op_end, &arg);
 526         fix_new_exp (frag_now,
 527                      (p - frag_now->fr_literal),
 528                      2,
 529                      &arg,
 530                      TRUE,
 531                      BFD_RELOC_MOXIE_10_PCREL);
 532       }
 533       break;
 534     default:
 535       abort ();
 536     }
 537
 538   md_number_to_chars (p, iword, 2);
 539
 540   while (ISSPACE (*op_end))
 541     op_end++;
 542
 543   if (*op_end != 0)
 544     as_warn (_("extra stuff on line ignored"));
 545
 546   if (pending_reloc)
 547     as_bad (_("Something forgot to clean up\n"));
 548 }
 549
 550 /* Turn a string in input_line_pointer into a floating point constant
 551    of type type, and store the appropriate bytes in *LITP.  The number
 552    of LITTLENUMS emitted is stored in *SIZEP .  An error message is
 553    returned, or NULL on OK.  */
 554
 555 char *
 556 md_atof (int type, char *litP, int *sizeP)
 557 {
 558   int prec;
 559   LITTLENUM_TYPE words[4];
 560   char *t;
 561   int i;
 562
 563   switch (type)
 564     {
 565     case 'f':
 566       prec = 2;
 567       break;
 568
 569     case 'd':
 570       prec = 4;
 571       break;
 572
 573     default:
 574       *sizeP = 0;
 575       return _("bad call to md_atof");
 576     }
 577
 578   t = atof_ieee (input_line_pointer, type, words);
 579   if (t)
 580     input_line_pointer = t;
 581
 582   *sizeP = prec * 2;
 583
 584   for (i = prec - 1; i >= 0; i--)
 585     {
 586       md_number_to_chars (litP, (valueT) words[i], 2);
 587       litP += 2;
 588     }
 589
 590   return NULL;
 591 }
 592 \f
 593 const char *md_shortopts = "";
 594
 595 struct option md_longopts[] =
 596 {
 597   {NULL, no_argument, NULL, 0}
 598 };
 599 size_t md_longopts_size = sizeof (md_longopts);
 600
 601 /* We have no target specific options yet, so these next
 602    two functions are empty.  */
 603 int
 604 md_parse_option (int c ATTRIBUTE_UNUSED, char *arg ATTRIBUTE_UNUSED)
 605 {
 606   return 0;
 607 }
 608
 609 void
 610 md_show_usage (FILE *stream ATTRIBUTE_UNUSED)
 611 {
 612 }
 613
 614 /* Apply a fixup to the object file.  */
 615
 616 void
 617 md_apply_fix (fixS *fixP ATTRIBUTE_UNUSED,
 618               valueT * valP ATTRIBUTE_UNUSED, segT seg ATTRIBUTE_UNUSED)
 619 {
 620   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
 621   long val = *valP;
 622   long newval;
 623   long max, min;
 624
 625   max = min = 0;
 626   switch (fixP->fx_r_type)
 627     {
 628     case BFD_RELOC_32:
 629       *buf++ = val >> 24;
 630       *buf++ = val >> 16;
 631       *buf++ = val >> 8;
 632       *buf++ = val >> 0;
 633       break;
 634
 635     case BFD_RELOC_16:
 636       *buf++ = val >> 8;
 637       *buf++ = val >> 0;
 638       break;
 639
 640     case BFD_RELOC_8:
 641       *buf++ = val;
 642       break;
 643
 644     case BFD_RELOC_MOXIE_10_PCREL:
 645       if (!val)
 646         break;
 647       if (val < -1024 || val > 1022)
 648         as_bad_where (fixP->fx_file, fixP->fx_line,
 649                       _("pcrel too far BFD_RELOC_MOXIE_10"));
 650       /* 11 bit offset even numbered, so we remove right bit.  */
 651       val >>= 1;
 652       newval = md_chars_to_number (buf, 2);
 653       newval |= val & 0x03ff;
 654       md_number_to_chars (buf, newval, 2);
 655       break;
 656
 657     default:
 658       abort ();
 659     }
 660
 661   if (max != 0 && (val < min || val > max))
 662     as_bad_where (fixP->fx_file, fixP->fx_line, _("offset out of range"));
 663
 664   if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
 665     fixP->fx_done = 1;
 666 }
 667
 668 /* Put number into target byte order (big endian).  */
 669
 670 void
 671 md_number_to_chars (char *ptr, valueT use, int nbytes)
 672 {
 673   number_to_chars_bigendian (ptr, use, nbytes);
 674 }
 675
 676 /* Convert from target byte order to host byte order.  */
 677
 678 static int
 679 md_chars_to_number (char *val, int n)
 680 {
 681   int retval = 0;
 682
 683   while (n--)
 684     {
 685       retval <<= 8;
 686       retval |= (*val++ & 255);
 687     }
 688
 689   return retval;
 690 }
 691
 692 /* Generate a machine-dependent relocation.  */
 693 arelent *
 694 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixP)
 695 {
 696   arelent *relP;
 697   bfd_reloc_code_real_type code;
 698
 699   switch (fixP->fx_r_type)
 700     {
 701     case BFD_RELOC_32:
 702       code = fixP->fx_r_type;
 703       break;
 704     case BFD_RELOC_MOXIE_10_PCREL:
 705       code = fixP->fx_r_type;
 706       break;
 707     default:
 708       as_bad_where (fixP->fx_file, fixP->fx_line,
 709                     _("Semantics error.  This type of operand can not be relocated, it must be an assembly-time constant"));
 710       return 0;
 711     }
 712
 713   relP = xmalloc (sizeof (arelent));
 714   gas_assert (relP != 0);
 715   relP->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
 716   *relP->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
 717   relP->address = fixP->fx_frag->fr_address + fixP->fx_where;
 718
 719   relP->addend = fixP->fx_offset;
 720
 721   /* This is the standard place for KLUDGEs to work around bugs in
 722      bfd_install_relocation (first such note in the documentation
 723      appears with binutils-2.8).
 724
 725      That function bfd_install_relocation does the wrong thing with
 726      putting stuff into the addend of a reloc (it should stay out) for a
 727      weak symbol.  The really bad thing is that it adds the
 728      "segment-relative offset" of the symbol into the reloc.  In this
 729      case, the reloc should instead be relative to the symbol with no
 730      other offset than the assembly code shows; and since the symbol is
 731      weak, any local definition should be ignored until link time (or
 732      thereafter).
 733      To wit:  weaksym+42  should be weaksym+42 in the reloc,
 734      not weaksym+(offset_from_segment_of_local_weaksym_definition)
 735
 736      To "work around" this, we subtract the segment-relative offset of
 737      "known" weak symbols.  This evens out the extra offset.
 738
 739      That happens for a.out but not for ELF, since for ELF,
 740      bfd_install_relocation uses the "special function" field of the
 741      howto, and does not execute the code that needs to be undone.  */
 742
 743   if (OUTPUT_FLAVOR == bfd_target_aout_flavour
 744       && fixP->fx_addsy && S_IS_WEAK (fixP->fx_addsy)
 745       && ! bfd_is_und_section (S_GET_SEGMENT (fixP->fx_addsy)))
 746     {
 747       relP->addend -= S_GET_VALUE (fixP->fx_addsy);
 748     }
 749
 750   relP->howto = bfd_reloc_type_lookup (stdoutput, code);
 751   if (! relP->howto)
 752     {
 753       const char *name;
 754
 755       name = S_GET_NAME (fixP->fx_addsy);
 756       if (name == NULL)
 757         name = _("<unknown>");
 758       as_fatal (_("Cannot generate relocation type for symbol %s, code %s"),
 759                 name, bfd_get_reloc_code_name (code));
 760     }
 761
 762   return relP;
 763 }
 764
 765 /* Decide from what point a pc-relative relocation is relative to,
 766    relative to the pc-relative fixup.  Er, relatively speaking.  */
 767 long
 768 md_pcrel_from (fixS *fixP)
 769 {
 770   valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;
 771
 772   switch (fixP->fx_r_type)
 773     {
 774     case BFD_RELOC_32:
 775       return addr + 4;
 776     case BFD_RELOC_MOXIE_10_PCREL:
 777       return addr;
 778     default:
 779       abort ();
 780       return addr;
 781     }
 782 }