gas/cgen.c

   1 /* GAS interface for targets using CGEN: Cpu tools GENerator.
   2    Copyright (C) 1996, 1997, 1998 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 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 the Free Software
  18 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
  19
  20 #include <setjmp.h>
  21 #include "ansidecl.h"
  22 #include "bfd.h"
  23 #include "symcat.h"
  24 #include "cgen-opc.h"
  25 #include "as.h"
  26 #include "subsegs.h"
  27 #include "cgen.h"
  28
  29 /* Callback to insert a register into the symbol table.
  30    A target may choose to let GAS parse the registers.
  31    ??? Not currently used.  */
  32
  33 void
  34 cgen_asm_record_register (name, number)
  35      char * name;
  36      int number;
  37 {
  38   /* Use symbol_create here instead of symbol_new so we don't try to
  39      output registers into the object file's symbol table.  */
  40   symbol_table_insert (symbol_create (name, reg_section,
  41                                       number, & zero_address_frag));
  42 }
  43
  44 /* We need to keep a list of fixups.  We can't simply generate them as
  45    we go, because that would require us to first create the frag, and
  46    that would screw up references to ``.''.
  47
  48    This is used by cpu's with simple operands.  It keeps knowledge of what
  49    an `expressionS' is and what a `fixup' is out of CGEN which for the time
  50    being is preferable.
  51
  52    OPINDEX is the index in the operand table.
  53    OPINFO is something the caller chooses to help in reloc determination.  */
  54
  55 struct fixup
  56 {
  57   int opindex;
  58   int opinfo;
  59   expressionS exp;
  60 };
  61
  62 static struct fixup fixups [CGEN_MAX_FIXUPS];
  63 static int num_fixups;
  64
  65 /* Prepare to parse an instruction.
  66    ??? May wish to make this static and delete calls in md_assemble.  */
  67
  68 void
  69 cgen_asm_init_parse ()
  70 {
  71   num_fixups = 0;
  72 }
  73
  74 /* Queue a fixup.  */
  75
  76 static void
  77 cgen_queue_fixup (opindex, opinfo, expP)
  78      int           opindex;
  79      expressionS * expP;
  80 {
  81   /* We need to generate a fixup for this expression.  */
  82   if (num_fixups >= CGEN_MAX_FIXUPS)
  83     as_fatal (_("too many fixups"));
  84   fixups[num_fixups].exp     = * expP;
  85   fixups[num_fixups].opindex = opindex;
  86   fixups[num_fixups].opinfo  = opinfo;
  87   ++ num_fixups;
  88 }
  89
  90 /* The following three functions allow a backup of the fixup chain to be made,
  91    and to have this backup be swapped with the current chain.  This allows
  92    certain ports, eg the m32r, to swap two instructions and swap their fixups
  93    at the same time.  */
  94 static struct fixup saved_fixups [CGEN_MAX_FIXUPS];
  95 static int saved_num_fixups;
  96
  97 void
  98 cgen_save_fixups ()
  99 {
 100   saved_num_fixups = num_fixups;
 101
 102   memcpy (saved_fixups, fixups, sizeof (fixups[0]) * num_fixups);
 103
 104   num_fixups = 0;
 105 }
 106
 107 void
 108 cgen_restore_fixups ()
 109 {
 110   num_fixups = saved_num_fixups;
 111
 112   memcpy (fixups, saved_fixups, sizeof (fixups[0]) * num_fixups);
 113
 114   saved_num_fixups = 0;
 115 }
 116
 117 void
 118 cgen_swap_fixups ()
 119 {
 120   int tmp;
 121   struct fixup tmp_fixup;
 122
 123   if (num_fixups == 0)
 124     {
 125       cgen_restore_fixups ();
 126     }
 127   else if (saved_num_fixups == 0)
 128     {
 129       cgen_save_fixups ();
 130     }
 131   else
 132     {
 133       tmp = saved_num_fixups;
 134       saved_num_fixups = num_fixups;
 135       num_fixups = tmp;
 136
 137       for (tmp = CGEN_MAX_FIXUPS; tmp--;)
 138         {
 139           tmp_fixup          = saved_fixups [tmp];
 140           saved_fixups [tmp] = fixups [tmp];
 141           fixups [tmp]       = tmp_fixup;
 142         }
 143     }
 144 }
 145
 146 /* Default routine to record a fixup.
 147    This is a cover function to fix_new.
 148    It exists because we record INSN with the fixup.
 149
 150    FRAG and WHERE are their respective arguments to fix_new_exp.
 151    LENGTH is in bits.
 152    OPINFO is something the caller chooses to help in reloc determination.
 153
 154    At this point we do not use a bfd_reloc_code_real_type for
 155    operands residing in the insn, but instead just use the
 156    operand index.  This lets us easily handle fixups for any
 157    operand type.  We pick a BFD reloc type in md_apply_fix.  */
 158
 159 fixS *
 160 cgen_record_fixup (frag, where, insn, length, operand, opinfo, symbol, offset)
 161      fragS *              frag;
 162      int                  where;
 163      const CGEN_INSN *    insn;
 164      int                  length;
 165      const CGEN_OPERAND * operand;
 166      int                  opinfo;
 167      symbolS *            symbol;
 168      offsetT              offset;
 169 {
 170   fixS * fixP;
 171
 172   /* It may seem strange to use operand->attrs and not insn->attrs here,
 173      but it is the operand that has a pc relative relocation.  */
 174
 175   fixP = fix_new (frag, where, length / 8, symbol, offset,
 176                   CGEN_OPERAND_ATTR (operand, CGEN_OPERAND_PCREL_ADDR) != 0,
 177                   (bfd_reloc_code_real_type) ((int) BFD_RELOC_UNUSED + CGEN_OPERAND_INDEX (operand)));
 178   fixP->tc_fix_data.insn   = (PTR) insn;
 179   fixP->tc_fix_data.opinfo = opinfo;
 180
 181   return fixP;
 182 }
 183
 184 /* Default routine to record a fixup given an expression.
 185    This is a cover function to fix_new_exp.
 186    It exists because we record INSN with the fixup.
 187
 188    FRAG and WHERE are their respective arguments to fix_new_exp.
 189    LENGTH is in bits.
 190    OPINFO is something the caller chooses to help in reloc determination.
 191
 192    At this point we do not use a bfd_reloc_code_real_type for
 193    operands residing in the insn, but instead just use the
 194    operand index.  This lets us easily handle fixups for any
 195    operand type.  We pick a BFD reloc type in md_apply_fix.  */
 196
 197 fixS *
 198 cgen_record_fixup_exp (frag, where, insn, length, operand, opinfo, exp)
 199      fragS *              frag;
 200      int                  where;
 201      const CGEN_INSN *    insn;
 202      int                  length;
 203      const CGEN_OPERAND * operand;
 204      int                  opinfo;
 205      expressionS *        exp;
 206 {
 207   fixS * fixP;
 208
 209   /* It may seem strange to use operand->attrs and not insn->attrs here,
 210      but it is the operand that has a pc relative relocation.  */
 211
 212   fixP = fix_new_exp (frag, where, length / 8, exp,
 213                       CGEN_OPERAND_ATTR (operand, CGEN_OPERAND_PCREL_ADDR) != 0,
 214                       (bfd_reloc_code_real_type) ((int) BFD_RELOC_UNUSED + CGEN_OPERAND_INDEX (operand)));
 215   fixP->tc_fix_data.insn = (PTR) insn;
 216   fixP->tc_fix_data.opinfo = opinfo;
 217
 218   return fixP;
 219 }
 220
 221 /* Used for communication between the next two procedures.  */
 222 static jmp_buf expr_jmp_buf;
 223
 224 /* Callback for cgen interface.  Parse the expression at *STRP.
 225    The result is an error message or NULL for success (in which case
 226    *STRP is advanced past the parsed text).
 227    WANT is an indication of what the caller is looking for.
 228    If WANT == CGEN_ASM_PARSE_INIT the caller is beginning to try to match
 229    a table entry with the insn, reset the queued fixups counter.
 230    An enum cgen_parse_operand_result is stored in RESULTP.
 231    OPINDEX is the operand's table entry index.
 232    OPINFO is something the caller chooses to help in reloc determination.
 233    The resulting value is stored in VALUEP.  */
 234
 235 const char *
 236 cgen_parse_operand (want, strP, opindex, opinfo, resultP, valueP)
 237      enum cgen_parse_operand_type want;
 238      const char ** strP;
 239      int opindex;
 240      int opinfo;
 241      enum cgen_parse_operand_result * resultP;
 242      bfd_vma * valueP;
 243 {
 244 #ifdef __STDC__
 245   /* These are volatile to survive the setjmp.  */
 246   char * volatile hold;
 247   enum cgen_parse_operand_result * volatile resultP_1;
 248 #else
 249   static char * hold;
 250   static enum cgen_parse_operand_result * resultP_1;
 251 #endif
 252   const char * errmsg = NULL;
 253   expressionS exp;
 254
 255   if (want == CGEN_PARSE_OPERAND_INIT)
 256     {
 257       cgen_asm_init_parse ();
 258       return NULL;
 259     }
 260
 261   resultP_1 = resultP;
 262   hold = input_line_pointer;
 263   input_line_pointer = (char *) * strP;
 264
 265   /* We rely on md_operand to longjmp back to us.
 266      This is done via cgen_md_operand.  */
 267   if (setjmp (expr_jmp_buf) != 0)
 268     {
 269       input_line_pointer = (char *) hold;
 270       * resultP_1 = CGEN_PARSE_OPERAND_RESULT_ERROR;
 271       return "illegal operand";
 272     }
 273
 274   expression (& exp);
 275
 276   * strP = input_line_pointer;
 277   input_line_pointer = hold;
 278
 279   /* FIXME: Need to check `want'.  */
 280
 281   switch (exp.X_op)
 282     {
 283     case O_illegal :
 284       errmsg = _("illegal operand");
 285       * resultP = CGEN_PARSE_OPERAND_RESULT_ERROR;
 286       break;
 287     case O_absent :
 288       errmsg = _("missing operand");
 289       * resultP = CGEN_PARSE_OPERAND_RESULT_ERROR;
 290       break;
 291     case O_constant :
 292       * valueP = exp.X_add_number;
 293       * resultP = CGEN_PARSE_OPERAND_RESULT_NUMBER;
 294       break;
 295     case O_register :
 296       * valueP = exp.X_add_number;
 297       * resultP = CGEN_PARSE_OPERAND_RESULT_REGISTER;
 298       break;
 299     default :
 300       cgen_queue_fixup (opindex, opinfo, & exp);
 301       * valueP = 0;
 302       * resultP = CGEN_PARSE_OPERAND_RESULT_QUEUED;
 303       break;
 304     }
 305
 306   return errmsg;
 307 }
 308
 309 /* md_operand handler to catch unrecognized expressions and halt the
 310    parsing process so the next entry can be tried.
 311
 312    ??? This could be done differently by adding code to `expression'.  */
 313
 314 void
 315 cgen_md_operand (expressionP)
 316      expressionS * expressionP;
 317 {
 318   longjmp (expr_jmp_buf, 1);
 319 }
 320
 321 /* Finish assembling instruction INSN.
 322    BUF contains what we've built up so far.
 323    LENGTH is the size of the insn in bits.
 324    RELAX_P is non-zero if relaxable insns should be emitted as such.
 325    Otherwise they're emitted in non-relaxable forms.
 326    The "result" is stored in RESULT if non-NULL.
 327    Returns the address of the buffer containing the assembled instruction,
 328    in case the caller needs to modify it for some reason. */
 329
 330 void
 331 cgen_asm_finish_insn (insn, buf, length, relax_p, result)
 332      const CGEN_INSN * insn;
 333      cgen_insn_t * buf;
 334      unsigned int length;
 335      int relax_p;
 336      finished_insnS * result;
 337 {
 338   int i;
 339   int relax_operand;
 340   char * f;
 341   unsigned int byte_len = length / 8;
 342
 343   /* ??? Target foo issues various warnings here, so one might want to provide
 344      a hook here.  However, our caller is defined in tc-foo.c so there
 345      shouldn't be a need for a hook.  */
 346
 347   /* Write out the instruction.
 348      It is important to fetch enough space in one call to `frag_more'.
 349      We use (f - frag_now->fr_literal) to compute where we are and we
 350      don't want frag_now to change between calls.
 351
 352      Relaxable instructions: We need to ensure we allocate enough
 353      space for the largest insn.  */
 354
 355   if (CGEN_INSN_ATTR (insn, CGEN_INSN_RELAX) != 0)
 356     abort (); /* These currently shouldn't get here.  */
 357
 358   /* Is there a relaxable insn with the relaxable operand needing a fixup?  */
 359
 360   relax_operand = -1;
 361   if (relax_p && CGEN_INSN_ATTR (insn, CGEN_INSN_RELAXABLE) != 0)
 362     {
 363       /* Scan the fixups for the operand affected by relaxing
 364          (i.e. the branch address).  */
 365
 366       for (i = 0; i < num_fixups; ++ i)
 367         {
 368           if (CGEN_OPERAND_ATTR (& CGEN_SYM (operand_table) [fixups[i].opindex],
 369                                  CGEN_OPERAND_RELAX) != 0)
 370             {
 371               relax_operand = i;
 372               break;
 373             }
 374         }
 375     }
 376
 377   if (relax_operand != -1)
 378     {
 379       int max_len;
 380       fragS * old_frag;
 381
 382 #ifdef TC_CGEN_MAX_RELAX
 383       max_len = TC_CGEN_MAX_RELAX (insn, byte_len);
 384 #else
 385       max_len = CGEN_MAX_INSN_SIZE;
 386 #endif
 387       /* Ensure variable part and fixed part are in same fragment.  */
 388       /* FIXME: Having to do this seems like a hack.  */
 389       frag_grow (max_len);
 390
 391       /* Allocate space for the fixed part.  */
 392       f = frag_more (byte_len);
 393
 394       /* Create a relaxable fragment for this instruction.  */
 395       old_frag = frag_now;
 396
 397       frag_var (rs_machine_dependent,
 398                 max_len - byte_len /* max chars */,
 399                 0 /* variable part already allocated */,
 400                 /* FIXME: When we machine generate the relax table,
 401                    machine generate a macro to compute subtype.  */
 402                 1 /* subtype */,
 403                 fixups[relax_operand].exp.X_add_symbol,
 404                 fixups[relax_operand].exp.X_add_number,
 405                 f);
 406
 407       /* Record the operand number with the fragment so md_convert_frag
 408          can use cgen_md_record_fixup to record the appropriate reloc.  */
 409       old_frag->fr_cgen.insn    = insn;
 410       old_frag->fr_cgen.opindex = fixups[relax_operand].opindex;
 411       old_frag->fr_cgen.opinfo  = fixups[relax_operand].opinfo;
 412       if (result)
 413         result->frag = old_frag;
 414     }
 415   else
 416     {
 417       f = frag_more (byte_len);
 418       if (result)
 419         result->frag = frag_now;
 420     }
 421
 422   /* If we're recording insns as numbers (rather than a string of bytes),
 423      target byte order handling is deferred until now.  */
 424 #if 0 /*def CGEN_INT_INSN*/
 425   switch (length)
 426     {
 427     case 16:
 428       if (cgen_big_endian_p)
 429         bfd_putb16 ((bfd_vma) * buf, f);
 430       else
 431         bfd_putl16 ((bfd_vma) * buf, f);
 432       break;
 433     case 32:
 434       if (cgen_big_endian_p)
 435         bfd_putb32 ((bfd_vma) * buf, f);
 436       else
 437         bfd_putl32 ((bfd_vma) * buf, f);
 438       break;
 439     default:
 440       abort ();
 441     }
 442 #else
 443   memcpy (f, buf, byte_len);
 444 #endif
 445
 446   /* Create any fixups.  */
 447   for (i = 0; i < num_fixups; ++i)
 448     {
 449       fixS * fixP;
 450
 451       /* Don't create fixups for these.  That's done during relaxation.
 452          We don't need to test for CGEN_INSN_RELAX as they can't get here
 453          (see above).  */
 454       if (relax_p
 455           && CGEN_INSN_ATTR (insn, CGEN_INSN_RELAXABLE) != 0
 456           && CGEN_OPERAND_ATTR (& CGEN_SYM (operand_table) [fixups[i].opindex],
 457                                 CGEN_OPERAND_RELAX) != 0)
 458         continue;
 459
 460 #ifndef md_cgen_record_fixup_exp
 461 #define md_cgen_record_fixup_exp cgen_record_fixup_exp
 462 #endif
 463
 464         fixP = md_cgen_record_fixup_exp (frag_now, f - frag_now->fr_literal,
 465                                          insn, length,
 466                                          & CGEN_SYM (operand_table) [fixups[i].opindex],
 467                                          fixups[i].opinfo,
 468                                          & fixups[i].exp);
 469         if (result)
 470           result->fixups[i] = fixP;
 471     }
 472
 473   if (result)
 474     {
 475       result->num_fixups = num_fixups;
 476       result->addr = f;
 477     }
 478 }
 479
 480 /* Apply a fixup to the object code.  This is called for all the
 481    fixups we generated by the call to fix_new_exp, above.  In the call
 482    above we used a reloc code which was the largest legal reloc code
 483    plus the operand index.  Here we undo that to recover the operand
 484    index.  At this point all symbol values should be fully resolved,
 485    and we attempt to completely resolve the reloc.  If we can not do
 486    that, we determine the correct reloc code and put it back in the fixup.  */
 487
 488 /* FIXME: This function handles some of the fixups and bfd_install_relocation
 489    handles the rest.  bfd_install_relocation (or some other bfd function)
 490    should handle them all.  */
 491
 492 int
 493 cgen_md_apply_fix3 (fixP, valueP, seg)
 494      fixS *   fixP;
 495      valueT * valueP;
 496      segT     seg;
 497 {
 498   char * where = fixP->fx_frag->fr_literal + fixP->fx_where;
 499   valueT value;
 500
 501   /* FIXME FIXME FIXME: The value we are passed in *valuep includes
 502      the symbol values.  Since we are using BFD_ASSEMBLER, if we are
 503      doing this relocation the code in write.c is going to call
 504      bfd_install_relocation, which is also going to use the symbol
 505      value.  That means that if the reloc is fully resolved we want to
 506      use *valuep since bfd_install_relocation is not being used.
 507      However, if the reloc is not fully resolved we do not want to use
 508      *valuep, and must use fx_offset instead.  However, if the reloc
 509      is PC relative, we do want to use *valuep since it includes the
 510      result of md_pcrel_from.  This is confusing.  */
 511
 512   if (fixP->fx_addsy == (symbolS *) NULL)
 513     {
 514       value = * valueP;
 515       fixP->fx_done = 1;
 516     }
 517   else if (fixP->fx_pcrel)
 518     value = * valueP;
 519   else
 520     {
 521       value = fixP->fx_offset;
 522       if (fixP->fx_subsy != (symbolS *) NULL)
 523         {
 524           if (S_GET_SEGMENT (fixP->fx_subsy) == absolute_section)
 525             value -= S_GET_VALUE (fixP->fx_subsy);
 526           else
 527             {
 528               /* We don't actually support subtracting a symbol.  */
 529               as_bad_where (fixP->fx_file, fixP->fx_line,
 530                             _("expression too complex"));
 531             }
 532         }
 533     }
 534
 535   if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
 536     {
 537       int                      opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
 538       const CGEN_OPERAND *     operand = & CGEN_SYM (operand_table) [opindex];
 539       const char *             errmsg;
 540       bfd_reloc_code_real_type reloc_type;
 541       CGEN_FIELDS              fields;
 542       const CGEN_INSN *        insn = (CGEN_INSN *) fixP->tc_fix_data.insn;
 543
 544       /* If the reloc has been fully resolved finish the operand here.  */
 545       /* FIXME: This duplicates the capabilities of code in BFD.  */
 546       if (fixP->fx_done
 547           /* FIXME: If partial_inplace isn't set bfd_install_relocation won't
 548              finish the job.  Testing for pcrel is a temporary hack.  */
 549           || fixP->fx_pcrel)
 550         {
 551           CGEN_FIELDS_BITSIZE (& fields) = CGEN_INSN_BITSIZE (insn);
 552           CGEN_SYM (set_operand) (opindex, & value, & fields);
 553           errmsg = CGEN_SYM (insert_operand) (opindex, & fields, where);
 554           if (errmsg)
 555             as_warn_where (fixP->fx_file, fixP->fx_line, "%s\n", errmsg);
 556         }
 557
 558       if (fixP->fx_done)
 559         return 1;
 560
 561       /* The operand isn't fully resolved.  Determine a BFD reloc value
 562          based on the operand information and leave it to
 563          bfd_install_relocation.  Note that this doesn't work when
 564          partial_inplace == false.  */
 565
 566       reloc_type = CGEN_SYM (lookup_reloc) (insn, operand, fixP);
 567       if (reloc_type != BFD_RELOC_NONE)
 568         {
 569           fixP->fx_r_type = reloc_type;
 570         }
 571       else
 572         {
 573           as_bad_where (fixP->fx_file, fixP->fx_line,
 574                         _("unresolved expression that must be resolved"));
 575           fixP->fx_done = 1;
 576           return 1;
 577         }
 578     }
 579   else if (fixP->fx_done)
 580     {
 581       /* We're finished with this fixup.  Install it because
 582          bfd_install_relocation won't be called to do it.  */
 583       switch (fixP->fx_r_type)
 584         {
 585         case BFD_RELOC_8:
 586           md_number_to_chars (where, value, 1);
 587           break;
 588         case BFD_RELOC_16:
 589           md_number_to_chars (where, value, 2);
 590           break;
 591         case BFD_RELOC_32:
 592           md_number_to_chars (where, value, 4);
 593           break;
 594         /* FIXME: later add support for 64 bits.  */
 595         default:
 596           abort ();
 597         }
 598     }
 599   else
 600     {
 601       /* bfd_install_relocation will be called to finish things up.  */
 602     }
 603
 604   /* Tuck `value' away for use by tc_gen_reloc.
 605      See the comment describing fx_addnumber in write.h.
 606      This field is misnamed (or misused :-).  */
 607   fixP->fx_addnumber = value;
 608
 609   return 1;
 610 }
 611
 612 /* Translate internal representation of relocation info to BFD target format.
 613
 614    FIXME: To what extent can we get all relevant targets to use this?  */
 615
 616 arelent *
 617 cgen_tc_gen_reloc (section, fixP)
 618      asection * section;
 619      fixS *     fixP;
 620 {
 621   arelent * reloc;
 622
 623   reloc = (arelent *) bfd_alloc (stdoutput, sizeof (arelent));
 624
 625   reloc->howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
 626   if (reloc->howto == (reloc_howto_type *) NULL)
 627     {
 628       as_bad_where (fixP->fx_file, fixP->fx_line,
 629                     _("internal error: can't export reloc type %d (`%s')"),
 630                     fixP->fx_r_type, bfd_get_reloc_code_name (fixP->fx_r_type));
 631       return NULL;
 632     }
 633
 634   assert (!fixP->fx_pcrel == !reloc->howto->pc_relative);
 635
 636   reloc->sym_ptr_ptr = & fixP->fx_addsy->bsym;
 637   reloc->address     = fixP->fx_frag->fr_address + fixP->fx_where;
 638   reloc->addend      = fixP->fx_addnumber;
 639
 640   return reloc;
 641 }