gas/config/tc-xstormy16.c

   1 /* tc-xstormy16.c -- Assembler for the Sanyo XSTORMY16.
   2    Copyright 2000, 2001, 2002, 2003 Free Software Foundation.
   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 2, 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, 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include <stdio.h>
  22 #include "as.h"
  23 #include "subsegs.h"
  24 #include "symcat.h"
  25 #include "opcodes/xstormy16-desc.h"
  26 #include "opcodes/xstormy16-opc.h"
  27 #include "cgen.h"
  28
  29 /* Structure to hold all of the different components describing
  30    an individual instruction.  */
  31 typedef struct
  32 {
  33   const CGEN_INSN *     insn;
  34   const CGEN_INSN *     orig_insn;
  35   CGEN_FIELDS           fields;
  36 #if CGEN_INT_INSN_P
  37   CGEN_INSN_INT         buffer [1];
  38 #define INSN_VALUE(buf) (*(buf))
  39 #else
  40   unsigned char         buffer [CGEN_MAX_INSN_SIZE];
  41 #define INSN_VALUE(buf) (buf)
  42 #endif
  43   char *                addr;
  44   fragS *               frag;
  45   int                   num_fixups;
  46   fixS *                fixups [GAS_CGEN_MAX_FIXUPS];
  47   int                   indices [MAX_OPERAND_INSTANCES];
  48 }
  49 xstormy16_insn;
  50
  51 const char comment_chars[]        = ";";
  52 const char line_comment_chars[]   = "#";
  53 const char line_separator_chars[] = "|";
  54 const char EXP_CHARS[]            = "eE";
  55 const char FLT_CHARS[]            = "dD";
  56
  57 #define O_fptr_symbol   (O_max + 1)
  58 \f
  59 #define XSTORMY16_SHORTOPTS ""
  60 const char * md_shortopts = XSTORMY16_SHORTOPTS;
  61
  62 struct option md_longopts[] =
  63 {
  64   {NULL, no_argument, NULL, 0}
  65 };
  66 size_t md_longopts_size = sizeof (md_longopts);
  67
  68 int
  69 md_parse_option (c, arg)
  70      int    c ATTRIBUTE_UNUSED;
  71      char * arg ATTRIBUTE_UNUSED;
  72 {
  73   return 0;
  74 }
  75
  76 void
  77 md_show_usage (stream)
  78   FILE * stream;
  79 {
  80   fprintf (stream, _(" XSTORMY16 specific command line options:\n"));
  81 }
  82
  83 /* The target specific pseudo-ops which we support.  */
  84 const pseudo_typeS md_pseudo_table[] =
  85 {
  86   { "word",     cons,           4 },
  87   { NULL,       NULL,           0 }
  88 };
  89
  90 \f
  91 void
  92 md_begin ()
  93 {
  94   /* Initialize the `cgen' interface.  */
  95
  96   /* Set the machine number and endian.  */
  97   gas_cgen_cpu_desc = xstormy16_cgen_cpu_open (CGEN_CPU_OPEN_MACHS, 0,
  98                                           CGEN_CPU_OPEN_ENDIAN,
  99                                           CGEN_ENDIAN_LITTLE,
 100                                           CGEN_CPU_OPEN_END);
 101   xstormy16_cgen_init_asm (gas_cgen_cpu_desc);
 102
 103   /* This is a callback from cgen to gas to parse operands.  */
 104   cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand);
 105 }
 106
 107 static bfd_boolean skipping_fptr = FALSE;
 108
 109 void
 110 md_assemble (str)
 111      char * str;
 112 {
 113   xstormy16_insn insn;
 114   char *    errmsg;
 115
 116   /* Make sure that if we had an erroneous input line which triggered
 117      the skipping_fptr boolean that it does not affect following lines.  */
 118   skipping_fptr = FALSE;
 119
 120   /* Initialize GAS's cgen interface for a new instruction.  */
 121   gas_cgen_init_parse ();
 122
 123   insn.insn = xstormy16_cgen_assemble_insn
 124     (gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg);
 125
 126   if (!insn.insn)
 127     {
 128       as_bad (errmsg);
 129       return;
 130     }
 131
 132   /* Doesn't really matter what we pass for RELAX_P here.  */
 133   gas_cgen_finish_insn (insn.insn, insn.buffer,
 134                         CGEN_FIELDS_BITSIZE (& insn.fields), 0, NULL);
 135 }
 136
 137 void
 138 md_operand (e)
 139      expressionS * e;
 140 {
 141   if (*input_line_pointer != '@')
 142     return;
 143
 144   if (strncmp (input_line_pointer+1, "fptr", 4) == 0)
 145     {
 146       input_line_pointer += 5;
 147       SKIP_WHITESPACE ();
 148       if (*input_line_pointer != '(')
 149         {
 150           as_bad ("Expected '('");
 151           goto err;
 152         }
 153       input_line_pointer++;
 154
 155       expression (e);
 156
 157       if (*input_line_pointer != ')')
 158         {
 159           as_bad ("Missing ')'");
 160           goto err;
 161         }
 162       input_line_pointer++;
 163       SKIP_WHITESPACE ();
 164
 165       if (e->X_op != O_symbol)
 166         as_bad ("Not a symbolic expression");
 167       else if (* input_line_pointer == '-')
 168         /* We are computing the difference of two function pointers
 169            like this:
 170
 171             .hword  @fptr (foo) - @fptr (bar)
 172
 173           In this situation we do not want to generate O_fptr_symbol
 174           operands because the result is an absolute value, not a
 175           function pointer.
 176
 177           We need to make the check here, rather than when the fixup
 178           is generated as the function names (foo & bar in the above
 179           example) might be local symbols and we want the expression
 180           to be evaluated now.  This kind of thing can happen when
 181           gcc is generating computed gotos.  */
 182         skipping_fptr = TRUE;
 183       else if (skipping_fptr)
 184         skipping_fptr = FALSE;
 185       else
 186         e->X_op = O_fptr_symbol;
 187     }
 188
 189   return;
 190  err:
 191   ignore_rest_of_line ();
 192 }
 193
 194 /* Called while parsing data to create a fixup.
 195    Create BFD_RELOC_XSTORMY16_FPTR16 relocations.  */
 196
 197 void
 198 xstormy16_cons_fix_new (f, where, nbytes, exp)
 199      fragS *f;
 200      int where;
 201      int nbytes;
 202      expressionS *exp;
 203 {
 204   bfd_reloc_code_real_type code;
 205   fixS *fix;
 206
 207   if (exp->X_op == O_fptr_symbol)
 208     {
 209       if (nbytes != 2)
 210         {
 211           as_bad ("unsupported fptr fixup size %d", nbytes);
 212           return;
 213         }
 214       exp->X_op = O_symbol;
 215       code = BFD_RELOC_XSTORMY16_FPTR16;
 216     }
 217   else if (nbytes == 1)
 218     code = BFD_RELOC_8;
 219   else if (nbytes == 2)
 220     code = BFD_RELOC_16;
 221   else if (nbytes == 4)
 222     code = BFD_RELOC_32;
 223   else
 224     {
 225       as_bad ("unsupported fixup size %d", nbytes);
 226       return;
 227     }
 228
 229   fix = fix_new_exp (f, where, nbytes, exp, 0, code);
 230 }
 231
 232 /* Called while parsing an instruction to create a fixup.
 233    Create BFD_RELOC_XSTORMY16_FPTR16 relocations.  */
 234
 235 fixS *
 236 xstormy16_cgen_record_fixup_exp (frag, where, insn, length, operand, opinfo, exp)
 237      fragS *              frag;
 238      int                  where;
 239      const CGEN_INSN *    insn;
 240      int                  length;
 241      const CGEN_OPERAND * operand;
 242      int                  opinfo;
 243      expressionS *        exp;
 244 {
 245   fixS *fixP;
 246   operatorT op = exp->X_op;
 247
 248   if (op == O_fptr_symbol)
 249     exp->X_op = O_symbol;
 250
 251   fixP = gas_cgen_record_fixup_exp (frag, where, insn, length,
 252                                     operand, opinfo, exp);
 253
 254   if (op == O_fptr_symbol)
 255     {
 256       if (operand->type != XSTORMY16_OPERAND_IMM16)
 257         as_bad ("unsupported fptr fixup");
 258       else
 259         {
 260           fixP->fx_r_type = BFD_RELOC_XSTORMY16_FPTR16;
 261           fixP->fx_where += 2;
 262         }
 263     }
 264
 265   return fixP;
 266 }
 267
 268 valueT
 269 md_section_align (segment, size)
 270      segT   segment;
 271      valueT size;
 272 {
 273   int align = bfd_get_section_alignment (stdoutput, segment);
 274   return ((size + (1 << align) - 1) & (-1 << align));
 275 }
 276
 277 symbolS *
 278 md_undefined_symbol (name)
 279   char * name ATTRIBUTE_UNUSED;
 280 {
 281   return 0;
 282 }
 283 \f
 284 /* Return an initial guess of the length by which a fragment must grow to
 285    hold a branch to reach its destination.
 286    Also updates fr_type/fr_subtype as necessary.
 287
 288    Called just before doing relaxation.
 289    Any symbol that is now undefined will not become defined.
 290    The guess for fr_var is ACTUALLY the growth beyond fr_fix.
 291    Whatever we do to grow fr_fix or fr_var contributes to our returned value.
 292    Although it may not be explicit in the frag, pretend fr_var starts with a
 293    0 value.  */
 294
 295 int
 296 md_estimate_size_before_relax (fragP, segment)
 297      fragS * fragP ATTRIBUTE_UNUSED;
 298      segT    segment ATTRIBUTE_UNUSED;
 299 {
 300   /* No assembler relaxation is defined (or necessary) for this port.  */
 301   abort ();
 302 }
 303
 304 /* *fragP has been relaxed to its final size, and now needs to have
 305    the bytes inside it modified to conform to the new size.
 306
 307    Called after relaxation is finished.
 308    fragP->fr_type == rs_machine_dependent.
 309    fragP->fr_subtype is the subtype of what the address relaxed to.  */
 310
 311 void
 312 md_convert_frag (abfd, sec, fragP)
 313   bfd *   abfd ATTRIBUTE_UNUSED;
 314   segT    sec ATTRIBUTE_UNUSED;
 315   fragS * fragP ATTRIBUTE_UNUSED;
 316 {
 317   /* No assembler relaxation is defined (or necessary) for this port.  */
 318   abort ();
 319 }
 320 \f
 321 /* Functions concerning relocs.  */
 322
 323 /* The location from which a PC relative jump should be calculated,
 324    given a PC relative reloc.  */
 325
 326 long
 327 md_pcrel_from_section (fixP, sec)
 328      fixS * fixP;
 329      segT   sec;
 330 {
 331   if (fixP->fx_addsy != (symbolS *) NULL
 332       && (! S_IS_DEFINED (fixP->fx_addsy)
 333           || S_GET_SEGMENT (fixP->fx_addsy) != sec))
 334     {
 335       /* The symbol is undefined (or is defined but not in this section).
 336          Let the linker figure it out.  */
 337       return 0;
 338     }
 339
 340   return fixP->fx_frag->fr_address + fixP->fx_where;
 341 }
 342
 343 /* Return the bfd reloc type for OPERAND of INSN at fixup FIXP.
 344    Returns BFD_RELOC_NONE if no reloc type can be found.
 345    *FIXP may be modified if desired.  */
 346
 347 bfd_reloc_code_real_type
 348 md_cgen_lookup_reloc (insn, operand, fixP)
 349      const CGEN_INSN *    insn ATTRIBUTE_UNUSED;
 350      const CGEN_OPERAND * operand;
 351      fixS *               fixP;
 352 {
 353   switch (operand->type)
 354     {
 355     case XSTORMY16_OPERAND_IMM2:
 356     case XSTORMY16_OPERAND_IMM3:
 357     case XSTORMY16_OPERAND_IMM3B:
 358     case XSTORMY16_OPERAND_IMM4:
 359     case XSTORMY16_OPERAND_HMEM8:
 360       return BFD_RELOC_NONE;
 361
 362     case XSTORMY16_OPERAND_IMM12:
 363       fixP->fx_where += 2;
 364       return BFD_RELOC_XSTORMY16_12;
 365
 366     case XSTORMY16_OPERAND_IMM8:
 367     case XSTORMY16_OPERAND_LMEM8:
 368       return fixP->fx_pcrel ? BFD_RELOC_8_PCREL : BFD_RELOC_8;
 369
 370     case XSTORMY16_OPERAND_IMM16:
 371       /* This might have been processed at parse time.  */
 372       fixP->fx_where += 2;
 373       if (fixP->fx_cgen.opinfo && fixP->fx_cgen.opinfo != BFD_RELOC_NONE)
 374         return fixP->fx_cgen.opinfo;
 375       return fixP->fx_pcrel ? BFD_RELOC_16_PCREL : BFD_RELOC_16;
 376
 377     case XSTORMY16_OPERAND_ABS24:
 378       return BFD_RELOC_XSTORMY16_24;
 379
 380     case XSTORMY16_OPERAND_REL8_4:
 381       fixP->fx_addnumber -= 2;
 382     case XSTORMY16_OPERAND_REL8_2:
 383       fixP->fx_addnumber -= 2;
 384       fixP->fx_pcrel = 1;
 385       return BFD_RELOC_8_PCREL;
 386
 387     case XSTORMY16_OPERAND_REL12:
 388       fixP->fx_where += 2;
 389       /* Fall through...  */
 390     case XSTORMY16_OPERAND_REL12A:
 391       fixP->fx_addnumber -= 2;
 392       fixP->fx_pcrel = 1;
 393       return BFD_RELOC_XSTORMY16_REL_12;
 394
 395     default : /* avoid -Wall warning */
 396       abort ();
 397     }
 398 }
 399
 400 /* See whether we need to force a relocation into the output file.
 401    This is used to force out switch and PC relative relocations when
 402    relaxing.  */
 403
 404 int
 405 xstormy16_force_relocation (fix)
 406      fixS * fix;
 407 {
 408   if (fix->fx_r_type == BFD_RELOC_XSTORMY16_FPTR16)
 409     return 1;
 410
 411   return generic_force_reloc (fix);
 412 }
 413
 414 /* Return true if a relocation against a symbol may be replaced with
 415    a relocation against section+offset.  */
 416
 417 bfd_boolean
 418 xstormy16_fix_adjustable (fixP)
 419    fixS * fixP;
 420 {
 421   /* We need the symbol name for the VTABLE entries.  */
 422   if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
 423       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
 424     return 0;
 425
 426   if (fixP->fx_r_type == BFD_RELOC_XSTORMY16_FPTR16)
 427     return 0;
 428
 429   return 1;
 430 }
 431
 432 /* This is a copy of gas_cgen_md_apply_fix3, with some enhancements to
 433    do various things that would not be valid for all ports.  */
 434
 435 void
 436 xstormy16_md_apply_fix3 (fixP, valueP, seg)
 437      fixS *   fixP;
 438      valueT * valueP;
 439      segT     seg ATTRIBUTE_UNUSED;
 440 {
 441   char *where = fixP->fx_frag->fr_literal + fixP->fx_where;
 442   valueT value = *valueP;
 443   /* Canonical name, since used a lot.  */
 444   CGEN_CPU_DESC cd = gas_cgen_cpu_desc;
 445
 446   /* md_cgen_lookup_reloc() will adjust this to compensate for where
 447      in the opcode the relocation happens, for pcrel relocations.  We
 448      have no other way of keeping track of what this offset needs to
 449      be.  */
 450   fixP->fx_addnumber = 0;
 451
 452   /* This port has pc-relative relocs and DIFF_EXPR_OK defined, so
 453      it must deal with turning a BFD_RELOC_{8,16,32,64} into a
 454      BFD_RELOC_*_PCREL for the case of
 455
 456         .word something-.
 457   */
 458   if (fixP->fx_pcrel)
 459     switch (fixP->fx_r_type)
 460       {
 461       case BFD_RELOC_8:
 462         fixP->fx_r_type = BFD_RELOC_8_PCREL;
 463         break;
 464       case BFD_RELOC_16:
 465         fixP->fx_r_type = BFD_RELOC_16_PCREL;
 466         break;
 467       case BFD_RELOC_32:
 468         fixP->fx_r_type = BFD_RELOC_32_PCREL;
 469         break;
 470       case BFD_RELOC_64:
 471         fixP->fx_r_type = BFD_RELOC_64_PCREL;
 472         break;
 473       default:
 474         break;
 475       }
 476
 477   if (fixP->fx_addsy == (symbolS *) NULL)
 478     fixP->fx_done = 1;
 479
 480   /* We don't actually support subtracting a symbol.  */
 481   if (fixP->fx_subsy != (symbolS *) NULL)
 482     as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));
 483
 484   if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
 485     {
 486       int opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
 487       const CGEN_OPERAND *operand = cgen_operand_lookup_by_num (cd, opindex);
 488       const char *errmsg;
 489       bfd_reloc_code_real_type reloc_type;
 490       CGEN_FIELDS *fields = alloca (CGEN_CPU_SIZEOF_FIELDS (cd));
 491       const CGEN_INSN *insn = fixP->fx_cgen.insn;
 492
 493       /* If the reloc has been fully resolved finish the operand here.  */
 494       /* FIXME: This duplicates the capabilities of code in BFD.  */
 495       if (fixP->fx_done)
 496         {
 497           CGEN_CPU_SET_FIELDS_BITSIZE (cd) (fields, CGEN_INSN_BITSIZE (insn));
 498           CGEN_CPU_SET_VMA_OPERAND (cd) (cd, opindex, fields, (bfd_vma) value);
 499
 500 #if CGEN_INT_INSN_P
 501           {
 502             CGEN_INSN_INT insn_value =
 503               cgen_get_insn_value (cd, where, CGEN_INSN_BITSIZE (insn));
 504
 505             /* ??? 0 is passed for `pc'.  */
 506             errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields,
 507                                                    &insn_value, (bfd_vma) 0);
 508             cgen_put_insn_value (cd, where, CGEN_INSN_BITSIZE (insn),
 509                                  insn_value);
 510           }
 511 #else
 512           /* ??? 0 is passed for `pc'.  */
 513           errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields, where,
 514                                                  (bfd_vma) 0);
 515 #endif
 516           if (errmsg)
 517             as_bad_where (fixP->fx_file, fixP->fx_line, "%s", errmsg);
 518         }
 519
 520       if (fixP->fx_done)
 521         return;
 522
 523       /* The operand isn't fully resolved.  Determine a BFD reloc value
 524          based on the operand information and leave it to
 525          bfd_install_relocation.  Note that this doesn't work when
 526          !partial_inplace.  */
 527
 528       reloc_type = md_cgen_lookup_reloc (insn, operand, fixP);
 529       if (reloc_type != BFD_RELOC_NONE)
 530         {
 531           fixP->fx_r_type = reloc_type;
 532         }
 533       else
 534         {
 535           as_bad_where (fixP->fx_file, fixP->fx_line,
 536                         _("unresolved expression that must be resolved"));
 537           fixP->fx_done = 1;
 538           return;
 539         }
 540     }
 541   else if (fixP->fx_done)
 542     {
 543       /* We're finished with this fixup.  Install it because
 544          bfd_install_relocation won't be called to do it.  */
 545       switch (fixP->fx_r_type)
 546         {
 547         case BFD_RELOC_8:
 548           md_number_to_chars (where, value, 1);
 549           break;
 550         case BFD_RELOC_16:
 551           md_number_to_chars (where, value, 2);
 552           break;
 553         case BFD_RELOC_32:
 554           md_number_to_chars (where, value, 4);
 555           break;
 556         case BFD_RELOC_64:
 557           md_number_to_chars (where, value, 8);
 558           break;
 559         default:
 560           as_bad_where (fixP->fx_file, fixP->fx_line,
 561                         _("internal error: can't install fix for reloc type %d (`%s')"),
 562                         fixP->fx_r_type, bfd_get_reloc_code_name (fixP->fx_r_type));
 563           break;
 564         }
 565     }
 566   else
 567     {
 568       /* bfd_install_relocation will be called to finish things up.  */
 569     }
 570
 571   /* This is a RELA port.  Thus, it does not need to store a
 572      value if it is going to make a reloc.  What's more, when
 573      assembling a line like
 574
 575      .byte global-0x7f00
 576
 577      we'll get a spurious error message if we try to stuff 0x7f00 into
 578      the byte.  */
 579   if (! fixP->fx_done)
 580     *valueP = 0;
 581
 582   /* Tuck `value' away for use by tc_gen_reloc.
 583      See the comment describing fx_addnumber in write.h.
 584      This field is misnamed (or misused :-).
 585      We do not do this for pc-relative relocs against a
 586      defined symbol, since it will be done for us.  */
 587   if ((! fixP->fx_pcrel)
 588       || (fixP->fx_addsy && ! S_IS_DEFINED (fixP->fx_addsy)))
 589     fixP->fx_addnumber += value;
 590 }
 591
 592 \f
 593 /* Write a value out to the object file, using the appropriate endianness.  */
 594
 595 void
 596 md_number_to_chars (buf, val, n)
 597      char * buf;
 598      valueT val;
 599      int    n;
 600 {
 601   number_to_chars_littleendian (buf, val, n);
 602 }
 603
 604 /* Turn a string in input_line_pointer into a floating point constant of type
 605    type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
 606    emitted is stored in *sizeP .  An error message is returned, or NULL on OK.
 607 */
 608
 609 /* Equal to MAX_PRECISION in atof-ieee.c */
 610 #define MAX_LITTLENUMS 6
 611
 612 char *
 613 md_atof (type, litP, sizeP)
 614      char   type;
 615      char * litP;
 616      int *  sizeP;
 617 {
 618   int              prec;
 619   LITTLENUM_TYPE   words [MAX_LITTLENUMS];
 620   LITTLENUM_TYPE   *wordP;
 621   char *           t;
 622
 623   switch (type)
 624     {
 625     case 'f':
 626     case 'F':
 627       prec = 2;
 628       break;
 629
 630     case 'd':
 631     case 'D':
 632       prec = 4;
 633       break;
 634
 635    /* FIXME: Some targets allow other format chars for bigger sizes here.  */
 636
 637     default:
 638       * sizeP = 0;
 639       return _("Bad call to md_atof()");
 640     }
 641
 642   t = atof_ieee (input_line_pointer, type, words);
 643   if (t)
 644     input_line_pointer = t;
 645   * sizeP = prec * sizeof (LITTLENUM_TYPE);
 646
 647   *sizeP = prec * sizeof (LITTLENUM_TYPE);
 648   /* This loops outputs the LITTLENUMs in REVERSE order; in accord with
 649      the littleendianness of the processor.  */
 650   for (wordP = words + prec - 1; prec--;)
 651     {
 652       md_number_to_chars (litP, (valueT) (*wordP--), sizeof (LITTLENUM_TYPE));
 653       litP += sizeof (LITTLENUM_TYPE);
 654     }
 655
 656   return 0;
 657 }