gas/cgen.c

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