ld/testsuite/
[binutils.git] / gas / cgen.c
blob5a5378999598b5117533ccd17371608e7101d772
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.
5 This file is part of GAS, the GNU Assembler.
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.
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.
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. */
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"
29 static void queue_fixup (int, int, expressionS *);
31 /* Opcode table descriptor, must be set by md_begin. */
33 CGEN_CPU_DESC gas_cgen_cpu_desc;
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. */
39 void
40 cgen_asm_record_register (name, number)
41 char *name;
42 int number;
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));
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 ``.''.
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.
58 OPINDEX is the index in the operand table.
59 OPINFO is something the caller chooses to help in reloc determination. */
61 struct fixup
63 int opindex;
64 int opinfo;
65 expressionS exp;
68 static struct fixup fixups[GAS_CGEN_MAX_FIXUPS];
69 static int num_fixups;
71 /* Prepare to parse an instruction.
72 ??? May wish to make this static and delete calls in md_assemble. */
74 void
75 gas_cgen_init_parse ()
77 num_fixups = 0;
80 /* Queue a fixup. */
82 static void
83 queue_fixup (opindex, opinfo, expP)
84 int opindex;
85 int opinfo;
86 expressionS * expP;
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;
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.
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.
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.
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.
123 gas_cgen_restore_fixups (element):
124 element - element number of the array you wish to restore the fixups
125 from.
127 gas_cgen_swap_fixups(int element):
128 element - swap the current fixups with those in this element number.
131 struct saved_fixups
133 struct fixup fixup_chain[GAS_CGEN_MAX_FIXUPS];
134 int num_fixups_in_chain;
137 static struct saved_fixups stored_fixups[MAX_SAVED_FIXUP_CHAINS];
139 void
140 gas_cgen_initialize_saved_fixups_array ()
142 int i = 0;
144 while (i < MAX_SAVED_FIXUP_CHAINS)
145 stored_fixups[i++].num_fixups_in_chain = 0;
148 void
149 gas_cgen_save_fixups (i)
150 int i;
152 if (i < 0 || i >= MAX_SAVED_FIXUP_CHAINS)
154 as_fatal ("index into stored_fixups[] out of bounds");
155 return;
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;
164 void
165 gas_cgen_restore_fixups (i)
166 int i;
168 if (i < 0 || i >= MAX_SAVED_FIXUP_CHAINS)
170 as_fatal ("index into stored_fixups[] out of bounds");
171 return;
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;
180 void
181 gas_cgen_swap_fixups (i)
182 int i;
184 if (i < 0 || i >= MAX_SAVED_FIXUP_CHAINS)
186 as_fatal ("index into stored_fixups[] out of bounds");
187 return;
190 if (num_fixups == 0)
191 gas_cgen_restore_fixups (i);
193 else if (stored_fixups[i].num_fixups_in_chain == 0)
194 gas_cgen_save_fixups (i);
196 else
198 int tmp;
199 struct fixup tmp_fixup;
201 tmp = stored_fixups[i].num_fixups_in_chain;
202 stored_fixups[i].num_fixups_in_chain = num_fixups;
203 num_fixups = tmp;
205 for (tmp = GAS_CGEN_MAX_FIXUPS; tmp--;)
207 tmp_fixup = stored_fixups[i].fixup_chain [tmp];
208 stored_fixups[i].fixup_chain[tmp] = fixups [tmp];
209 fixups [tmp] = tmp_fixup;
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.
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.
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. */
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;
238 fixS *fixP;
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;
250 return fixP;
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.
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.
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. */
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;
276 fixS *fixP;
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;
288 return fixP;
291 /* Used for communication between the next two procedures. */
292 static jmp_buf expr_jmp_buf;
293 static int expr_jmp_buf_p;
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. */
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;
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;
329 if (want == CGEN_PARSE_OPERAND_INIT)
331 gas_cgen_init_parse ();
332 return NULL;
335 resultP_1 = resultP;
336 hold = input_line_pointer;
337 input_line_pointer = (char *) *strP;
338 opinfo_1 = opinfo;
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)
344 expr_jmp_buf_p = 0;
345 input_line_pointer = (char *) hold;
346 *resultP_1 = CGEN_PARSE_OPERAND_RESULT_ERROR;
347 return _("illegal operand");
350 expr_jmp_buf_p = 1;
351 expression (&exp);
352 expr_jmp_buf_p = 0;
353 errmsg = NULL;
355 *strP = input_line_pointer;
356 input_line_pointer = hold;
358 #ifdef TC_CGEN_PARSE_FIX_EXP
359 opinfo_1 = TC_CGEN_PARSE_FIX_EXP (opinfo_1, & exp);
360 #endif
362 /* FIXME: Need to check `want'. */
364 switch (exp.X_op)
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;
392 return errmsg;
395 /* md_operand handler to catch unrecognized expressions and halt the
396 parsing process so the next entry can be tried.
398 ??? This could be done differently by adding code to `expression'. */
400 void
401 gas_cgen_md_operand (expressionP)
402 expressionS *expressionP ATTRIBUTE_UNUSED;
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);
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. */
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;
424 int i;
425 int relax_operand;
426 char *f;
427 unsigned int byte_len = length / 8;
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. */
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.
438 Relaxable instructions: We need to ensure we allocate enough
439 space for the largest insn. */
441 if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED))
442 /* These currently shouldn't get here. */
443 abort ();
445 /* Is there a relaxable insn with the relaxable operand needing a fixup? */
447 relax_operand = -1;
448 if (relax_p && CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXABLE))
450 /* Scan the fixups for the operand affected by relaxing
451 (i.e. the branch address). */
453 for (i = 0; i < num_fixups; ++i)
455 if (CGEN_OPERAND_ATTR_VALUE (cgen_operand_lookup_by_num (gas_cgen_cpu_desc, fixups[i].opindex),
456 CGEN_OPERAND_RELAX))
458 relax_operand = i;
459 break;
464 if (relax_operand != -1)
466 int max_len;
467 fragS *old_frag;
468 expressionS *exp;
469 symbolS *sym;
470 offsetT off;
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);
481 /* Allocate space for the fixed part. */
482 f = frag_more (byte_len);
484 /* Create a relaxable fragment for this instruction. */
485 old_frag = frag_now;
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)
492 /* Handle complex expressions. */
493 sym = make_expr_symbol (exp);
494 off = 0;
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,
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;
515 else
517 f = frag_more (byte_len);
518 if (result)
519 result->frag = frag_now;
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
530 /* Emit DWARF2 debugging information. */
531 dwarf2_emit_insn (byte_len);
533 /* Create any fixups. */
534 for (i = 0; i < num_fixups; ++i)
536 fixS *fixP;
537 const CGEN_OPERAND *operand =
538 cgen_operand_lookup_by_num (gas_cgen_cpu_desc, fixups[i].opindex);
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;
548 #ifndef md_cgen_record_fixup_exp
549 #define md_cgen_record_fixup_exp gas_cgen_record_fixup_exp
550 #endif
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;
560 if (result)
562 result->num_fixups = num_fixups;
563 result->addr = f;
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. */
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. */
579 void
580 gas_cgen_md_apply_fix (fixP, valP, seg)
581 fixS * fixP;
582 valueT * valP;
583 segT seg ATTRIBUTE_UNUSED;
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;
590 if (fixP->fx_addsy == (symbolS *) NULL)
591 fixP->fx_done = 1;
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"));
597 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
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;
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)
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);
616 #if CGEN_INT_INSN_P
618 CGEN_INSN_INT insn_value =
619 cgen_get_insn_value (cd, (unsigned char *) where,
620 CGEN_INSN_BITSIZE (insn));
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);
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);
638 if (fixP->fx_done)
639 return;
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. */
646 reloc_type = md_cgen_lookup_reloc (insn, operand, fixP);
648 if (reloc_type != BFD_RELOC_NONE)
649 fixP->fx_r_type = reloc_type;
650 else
652 as_bad_where (fixP->fx_file, fixP->fx_line,
653 _("unresolved expression that must be resolved"));
654 fixP->fx_done = 1;
655 return;
658 else if (fixP->fx_done)
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)
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;
683 /* else
684 bfd_install_relocation will be called to finish things up. */
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;
692 /* Translate internal representation of relocation info to BFD target format.
694 FIXME: To what extent can we get all relevant targets to use this? */
696 arelent *
697 gas_cgen_tc_gen_reloc (section, fixP)
698 asection * section ATTRIBUTE_UNUSED;
699 fixS * fixP;
701 arelent *reloc;
703 reloc = (arelent *) xmalloc (sizeof (arelent));
705 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
706 if (reloc->howto == (reloc_howto_type *) NULL)
708 as_bad_where (fixP->fx_file, fixP->fx_line,
709 _("relocation is not supported"));
710 return NULL;
713 assert (!fixP->fx_pcrel == !reloc->howto->pc_relative);
715 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
716 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
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;
725 reloc->address = fixP->fx_frag->fr_address + fixP->fx_where;
726 return reloc;
729 /* Perform any cgen specific initialisation.
730 Called after gas_cgen_cpu_desc has been created. */
732 void
733 gas_cgen_begin ()
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);