gas/cgen.c

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