daily update
[binutils.git] / gas / cgen.c
blob5ce7f4c99ecba6c155913414f8c36a95b8b99f88
1 /* GAS interface for targets using CGEN: Cpu tools GENerator.
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 #include <setjmp.h>
22 #include "ansidecl.h"
23 #include "libiberty.h"
24 #include "bfd.h"
25 #include "symcat.h"
26 #include "cgen-desc.h"
27 #include "as.h"
28 #include "subsegs.h"
29 #include "cgen.h"
30 #include "dwarf2dbg.h"
32 static void queue_fixup (int, int, expressionS *);
34 /* Opcode table descriptor, must be set by md_begin. */
36 CGEN_CPU_DESC gas_cgen_cpu_desc;
38 /* Callback to insert a register into the symbol table.
39 A target may choose to let GAS parse the registers.
40 ??? Not currently used. */
42 void
43 cgen_asm_record_register (name, number)
44 char *name;
45 int number;
47 /* Use symbol_create here instead of symbol_new so we don't try to
48 output registers into the object file's symbol table. */
49 symbol_table_insert (symbol_create (name, reg_section,
50 number, &zero_address_frag));
53 /* We need to keep a list of fixups. We can't simply generate them as
54 we go, because that would require us to first create the frag, and
55 that would screw up references to ``.''.
57 This is used by cpu's with simple operands. It keeps knowledge of what
58 an `expressionS' is and what a `fixup' is out of CGEN which for the time
59 being is preferable.
61 OPINDEX is the index in the operand table.
62 OPINFO is something the caller chooses to help in reloc determination. */
64 struct fixup
66 int opindex;
67 int opinfo;
68 expressionS exp;
71 static struct fixup fixups[GAS_CGEN_MAX_FIXUPS];
72 static int num_fixups;
74 /* Prepare to parse an instruction.
75 ??? May wish to make this static and delete calls in md_assemble. */
77 void
78 gas_cgen_init_parse ()
80 num_fixups = 0;
83 /* Queue a fixup. */
85 static void
86 queue_fixup (opindex, opinfo, expP)
87 int opindex;
88 int opinfo;
89 expressionS * expP;
91 /* We need to generate a fixup for this expression. */
92 if (num_fixups >= GAS_CGEN_MAX_FIXUPS)
93 as_fatal (_("too many fixups"));
94 fixups[num_fixups].exp = *expP;
95 fixups[num_fixups].opindex = opindex;
96 fixups[num_fixups].opinfo = opinfo;
97 ++ num_fixups;
100 /* The following functions allow fixup chains to be stored, retrieved,
101 and swapped. They are a generalization of a pre-existing scheme
102 for storing, restoring and swapping fixup chains that was used by
103 the m32r port. The functionality is essentially the same, only
104 instead of only being able to store a single fixup chain, an entire
105 array of fixup chains can be stored. It is the user's responsibility
106 to keep track of how many fixup chains have been stored and which
107 elements of the array they are in.
109 The algorithms used are the same as in the old scheme. Other than the
110 "array-ness" of the whole thing, the functionality is identical to the
111 old scheme.
113 gas_cgen_initialize_saved_fixups_array():
114 Sets num_fixups_in_chain to 0 for each element. Call this from
115 md_begin() if you plan to use these functions and you want the
116 fixup count in each element to be set to 0 initially. This is
117 not necessary, but it's included just in case. It performs
118 the same function for each element in the array of fixup chains
119 that gas_init_parse() performs for the current fixups.
121 gas_cgen_save_fixups (element):
122 element - element number of the array you wish to store the fixups
123 to. No mechanism is built in for tracking what element
124 was last stored to.
126 gas_cgen_restore_fixups (element):
127 element - element number of the array you wish to restore the fixups
128 from.
130 gas_cgen_swap_fixups(int element):
131 element - swap the current fixups with those in this element number.
134 struct saved_fixups
136 struct fixup fixup_chain[GAS_CGEN_MAX_FIXUPS];
137 int num_fixups_in_chain;
140 static struct saved_fixups stored_fixups[MAX_SAVED_FIXUP_CHAINS];
142 void
143 gas_cgen_initialize_saved_fixups_array ()
145 int i = 0;
147 while (i < MAX_SAVED_FIXUP_CHAINS)
148 stored_fixups[i++].num_fixups_in_chain = 0;
151 void
152 gas_cgen_save_fixups (i)
153 int i;
155 if (i < 0 || i >= MAX_SAVED_FIXUP_CHAINS)
157 as_fatal ("index into stored_fixups[] out of bounds");
158 return;
161 stored_fixups[i].num_fixups_in_chain = num_fixups;
162 memcpy (stored_fixups[i].fixup_chain, fixups,
163 sizeof (fixups[0]) * num_fixups);
164 num_fixups = 0;
167 void
168 gas_cgen_restore_fixups (i)
169 int i;
171 if (i < 0 || i >= MAX_SAVED_FIXUP_CHAINS)
173 as_fatal ("index into stored_fixups[] out of bounds");
174 return;
177 num_fixups = stored_fixups[i].num_fixups_in_chain;
178 memcpy (fixups, stored_fixups[i].fixup_chain,
179 (sizeof (stored_fixups[i].fixup_chain[0])) * num_fixups);
180 stored_fixups[i].num_fixups_in_chain = 0;
183 void
184 gas_cgen_swap_fixups (i)
185 int i;
187 if (i < 0 || i >= MAX_SAVED_FIXUP_CHAINS)
189 as_fatal ("index into stored_fixups[] out of bounds");
190 return;
193 if (num_fixups == 0)
194 gas_cgen_restore_fixups (i);
196 else if (stored_fixups[i].num_fixups_in_chain == 0)
197 gas_cgen_save_fixups (i);
199 else
201 int tmp;
202 struct fixup tmp_fixup;
204 tmp = stored_fixups[i].num_fixups_in_chain;
205 stored_fixups[i].num_fixups_in_chain = num_fixups;
206 num_fixups = tmp;
208 for (tmp = GAS_CGEN_MAX_FIXUPS; tmp--;)
210 tmp_fixup = stored_fixups[i].fixup_chain [tmp];
211 stored_fixups[i].fixup_chain[tmp] = fixups [tmp];
212 fixups [tmp] = tmp_fixup;
217 /* Default routine to record a fixup.
218 This is a cover function to fix_new.
219 It exists because we record INSN with the fixup.
221 FRAG and WHERE are their respective arguments to fix_new_exp.
222 LENGTH is in bits.
223 OPINFO is something the caller chooses to help in reloc determination.
225 At this point we do not use a bfd_reloc_code_real_type for
226 operands residing in the insn, but instead just use the
227 operand index. This lets us easily handle fixups for any
228 operand type. We pick a BFD reloc type in md_apply_fix3. */
230 fixS *
231 gas_cgen_record_fixup (frag, where, insn, length, operand, opinfo, symbol, offset)
232 fragS * frag;
233 int where;
234 const CGEN_INSN * insn;
235 int length;
236 const CGEN_OPERAND * operand;
237 int opinfo;
238 symbolS * symbol;
239 offsetT offset;
241 fixS *fixP;
243 /* It may seem strange to use operand->attrs and not insn->attrs here,
244 but it is the operand that has a pc relative relocation. */
245 fixP = fix_new (frag, where, length / 8, symbol, offset,
246 CGEN_OPERAND_ATTR_VALUE (operand, CGEN_OPERAND_PCREL_ADDR),
247 (bfd_reloc_code_real_type)
248 ((int) BFD_RELOC_UNUSED
249 + (int) operand->type));
250 fixP->fx_cgen.insn = insn;
251 fixP->fx_cgen.opinfo = opinfo;
253 return fixP;
256 /* Default routine to record a fixup given an expression.
257 This is a cover function to fix_new_exp.
258 It exists because we record INSN with the fixup.
260 FRAG and WHERE are their respective arguments to fix_new_exp.
261 LENGTH is in bits.
262 OPINFO is something the caller chooses to help in reloc determination.
264 At this point we do not use a bfd_reloc_code_real_type for
265 operands residing in the insn, but instead just use the
266 operand index. This lets us easily handle fixups for any
267 operand type. We pick a BFD reloc type in md_apply_fix3. */
269 fixS *
270 gas_cgen_record_fixup_exp (frag, where, insn, length, operand, opinfo, exp)
271 fragS * frag;
272 int where;
273 const CGEN_INSN * insn;
274 int length;
275 const CGEN_OPERAND * operand;
276 int opinfo;
277 expressionS * exp;
279 fixS *fixP;
281 /* It may seem strange to use operand->attrs and not insn->attrs here,
282 but it is the operand that has a pc relative relocation. */
283 fixP = fix_new_exp (frag, where, length / 8, exp,
284 CGEN_OPERAND_ATTR_VALUE (operand, CGEN_OPERAND_PCREL_ADDR),
285 (bfd_reloc_code_real_type)
286 ((int) BFD_RELOC_UNUSED
287 + (int) operand->type));
288 fixP->fx_cgen.insn = insn;
289 fixP->fx_cgen.opinfo = opinfo;
291 return fixP;
294 /* Used for communication between the next two procedures. */
295 static jmp_buf expr_jmp_buf;
296 static int expr_jmp_buf_p;
298 /* Callback for cgen interface. Parse the expression at *STRP.
299 The result is an error message or NULL for success (in which case
300 *STRP is advanced past the parsed text).
301 WANT is an indication of what the caller is looking for.
302 If WANT == CGEN_ASM_PARSE_INIT the caller is beginning to try to match
303 a table entry with the insn, reset the queued fixups counter.
304 An enum cgen_parse_operand_result is stored in RESULTP.
305 OPINDEX is the operand's table entry index.
306 OPINFO is something the caller chooses to help in reloc determination.
307 The resulting value is stored in VALUEP. */
309 const char *
310 gas_cgen_parse_operand (cd, want, strP, opindex, opinfo, resultP, valueP)
311 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
312 enum cgen_parse_operand_type want;
313 const char **strP;
314 int opindex;
315 int opinfo;
316 enum cgen_parse_operand_result *resultP;
317 bfd_vma *valueP;
319 #ifdef __STDC__
320 /* These are volatile to survive the setjmp. */
321 char * volatile hold;
322 enum cgen_parse_operand_result * volatile resultP_1;
323 #else
324 static char *hold;
325 static enum cgen_parse_operand_result *resultP_1;
326 #endif
327 const char *errmsg;
328 expressionS exp;
330 if (want == CGEN_PARSE_OPERAND_INIT)
332 gas_cgen_init_parse ();
333 return NULL;
336 resultP_1 = resultP;
337 hold = input_line_pointer;
338 input_line_pointer = (char *) *strP;
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 /* FIXME: Need to check `want'. */
360 switch (exp.X_op)
362 case O_illegal:
363 errmsg = _("illegal operand");
364 *resultP = CGEN_PARSE_OPERAND_RESULT_ERROR;
365 break;
366 case O_absent:
367 errmsg = _("missing operand");
368 *resultP = CGEN_PARSE_OPERAND_RESULT_ERROR;
369 break;
370 case O_constant:
371 *valueP = exp.X_add_number;
372 *resultP = CGEN_PARSE_OPERAND_RESULT_NUMBER;
373 break;
374 case O_register:
375 *valueP = exp.X_add_number;
376 *resultP = CGEN_PARSE_OPERAND_RESULT_REGISTER;
377 break;
378 default:
379 queue_fixup (opindex, opinfo, &exp);
380 *valueP = 0;
381 *resultP = CGEN_PARSE_OPERAND_RESULT_QUEUED;
382 break;
385 return errmsg;
388 /* md_operand handler to catch unrecognized expressions and halt the
389 parsing process so the next entry can be tried.
391 ??? This could be done differently by adding code to `expression'. */
393 void
394 gas_cgen_md_operand (expressionP)
395 expressionS *expressionP ATTRIBUTE_UNUSED;
397 /* Don't longjmp if we're not called from within cgen_parse_operand(). */
398 if (expr_jmp_buf_p)
399 longjmp (expr_jmp_buf, 1);
402 /* Finish assembling instruction INSN.
403 BUF contains what we've built up so far.
404 LENGTH is the size of the insn in bits.
405 RELAX_P is non-zero if relaxable insns should be emitted as such.
406 Otherwise they're emitted in non-relaxable forms.
407 The "result" is stored in RESULT if non-NULL. */
409 void
410 gas_cgen_finish_insn (insn, buf, length, relax_p, result)
411 const CGEN_INSN *insn;
412 CGEN_INSN_BYTES_PTR buf;
413 unsigned int length;
414 int relax_p;
415 finished_insnS *result;
417 int i;
418 int relax_operand;
419 char *f;
420 unsigned int byte_len = length / 8;
422 /* ??? Target foo issues various warnings here, so one might want to provide
423 a hook here. However, our caller is defined in tc-foo.c so there
424 shouldn't be a need for a hook. */
426 /* Write out the instruction.
427 It is important to fetch enough space in one call to `frag_more'.
428 We use (f - frag_now->fr_literal) to compute where we are and we
429 don't want frag_now to change between calls.
431 Relaxable instructions: We need to ensure we allocate enough
432 space for the largest insn. */
434 if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED))
435 /* These currently shouldn't get here. */
436 abort ();
438 /* Is there a relaxable insn with the relaxable operand needing a fixup? */
440 relax_operand = -1;
441 if (relax_p && CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXABLE))
443 /* Scan the fixups for the operand affected by relaxing
444 (i.e. the branch address). */
446 for (i = 0; i < num_fixups; ++i)
448 if (CGEN_OPERAND_ATTR_VALUE (cgen_operand_lookup_by_num (gas_cgen_cpu_desc, fixups[i].opindex),
449 CGEN_OPERAND_RELAX))
451 relax_operand = i;
452 break;
457 if (relax_operand != -1)
459 int max_len;
460 fragS *old_frag;
461 expressionS *exp;
462 symbolS *sym;
463 offsetT off;
465 #ifdef TC_CGEN_MAX_RELAX
466 max_len = TC_CGEN_MAX_RELAX (insn, byte_len);
467 #else
468 max_len = CGEN_MAX_INSN_SIZE;
469 #endif
470 /* Ensure variable part and fixed part are in same fragment. */
471 /* FIXME: Having to do this seems like a hack. */
472 frag_grow (max_len);
474 /* Allocate space for the fixed part. */
475 f = frag_more (byte_len);
477 /* Create a relaxable fragment for this instruction. */
478 old_frag = frag_now;
480 exp = &fixups[relax_operand].exp;
481 sym = exp->X_add_symbol;
482 off = exp->X_add_number;
483 if (exp->X_op != O_constant && exp->X_op != O_symbol)
485 /* Handle complex expressions. */
486 sym = make_expr_symbol (exp);
487 off = 0;
490 frag_var (rs_machine_dependent,
491 max_len - byte_len /* max chars */,
492 0 /* variable part already allocated */,
493 /* FIXME: When we machine generate the relax table,
494 machine generate a macro to compute subtype. */
495 1 /* subtype */,
496 sym,
497 off,
500 /* Record the operand number with the fragment so md_convert_frag
501 can use gas_cgen_md_record_fixup to record the appropriate reloc. */
502 old_frag->fr_cgen.insn = insn;
503 old_frag->fr_cgen.opindex = fixups[relax_operand].opindex;
504 old_frag->fr_cgen.opinfo = fixups[relax_operand].opinfo;
505 if (result)
506 result->frag = old_frag;
508 else
510 f = frag_more (byte_len);
511 if (result)
512 result->frag = frag_now;
515 /* If we're recording insns as numbers (rather than a string of bytes),
516 target byte order handling is deferred until now. */
517 #if CGEN_INT_INSN_P
518 cgen_put_insn_value (gas_cgen_cpu_desc, f, length, *buf);
519 #else
520 memcpy (f, buf, byte_len);
521 #endif
523 /* Emit DWARF2 debugging information. */
524 dwarf2_emit_insn (byte_len);
526 /* Create any fixups. */
527 for (i = 0; i < num_fixups; ++i)
529 fixS *fixP;
530 const CGEN_OPERAND *operand =
531 cgen_operand_lookup_by_num (gas_cgen_cpu_desc, fixups[i].opindex);
533 /* Don't create fixups for these. That's done during relaxation.
534 We don't need to test for CGEN_INSN_RELAXED as they can't get here
535 (see above). */
536 if (relax_p
537 && CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXABLE)
538 && CGEN_OPERAND_ATTR_VALUE (operand, CGEN_OPERAND_RELAX))
539 continue;
541 #ifndef md_cgen_record_fixup_exp
542 #define md_cgen_record_fixup_exp gas_cgen_record_fixup_exp
543 #endif
545 fixP = md_cgen_record_fixup_exp (frag_now, f - frag_now->fr_literal,
546 insn, length, operand,
547 fixups[i].opinfo,
548 &fixups[i].exp);
549 if (result)
550 result->fixups[i] = fixP;
553 if (result)
555 result->num_fixups = num_fixups;
556 result->addr = f;
560 /* Apply a fixup to the object code. This is called for all the
561 fixups we generated by the call to fix_new_exp, above. In the call
562 above we used a reloc code which was the largest legal reloc code
563 plus the operand index. Here we undo that to recover the operand
564 index. At this point all symbol values should be fully resolved,
565 and we attempt to completely resolve the reloc. If we can not do
566 that, we determine the correct reloc code and put it back in the fixup. */
568 /* FIXME: This function handles some of the fixups and bfd_install_relocation
569 handles the rest. bfd_install_relocation (or some other bfd function)
570 should handle them all. */
572 void
573 gas_cgen_md_apply_fix3 (fixP, valP, seg)
574 fixS * fixP;
575 valueT * valP;
576 segT seg ATTRIBUTE_UNUSED;
578 char *where = fixP->fx_frag->fr_literal + fixP->fx_where;
579 valueT value = * valP;
580 /* Canonical name, since used a lot. */
581 CGEN_CPU_DESC cd = gas_cgen_cpu_desc;
583 if (fixP->fx_addsy == (symbolS *) NULL)
584 fixP->fx_done = 1;
586 /* We don't actually support subtracting a symbol. */
587 if (fixP->fx_subsy != (symbolS *) NULL)
588 as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));
590 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
592 int opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
593 const CGEN_OPERAND *operand = cgen_operand_lookup_by_num (cd, opindex);
594 const char *errmsg;
595 bfd_reloc_code_real_type reloc_type;
596 CGEN_FIELDS *fields = alloca (CGEN_CPU_SIZEOF_FIELDS (cd));
597 const CGEN_INSN *insn = fixP->fx_cgen.insn;
599 /* If the reloc has been fully resolved finish the operand here. */
600 /* FIXME: This duplicates the capabilities of code in BFD. */
601 if (fixP->fx_done
602 /* FIXME: If partial_inplace isn't set bfd_install_relocation won't
603 finish the job. Testing for pcrel is a temporary hack. */
604 || fixP->fx_pcrel)
606 CGEN_CPU_SET_FIELDS_BITSIZE (cd) (fields, CGEN_INSN_BITSIZE (insn));
607 CGEN_CPU_SET_VMA_OPERAND (cd) (cd, opindex, fields, (bfd_vma) value);
609 #if CGEN_INT_INSN_P
611 CGEN_INSN_INT insn_value =
612 cgen_get_insn_value (cd, where, CGEN_INSN_BITSIZE (insn));
614 /* ??? 0 is passed for `pc'. */
615 errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields,
616 &insn_value, (bfd_vma) 0);
617 cgen_put_insn_value (cd, where, CGEN_INSN_BITSIZE (insn),
618 insn_value);
620 #else
621 /* ??? 0 is passed for `pc'. */
622 errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields, where,
623 (bfd_vma) 0);
624 #endif
625 if (errmsg)
626 as_bad_where (fixP->fx_file, fixP->fx_line, "%s", errmsg);
629 if (fixP->fx_done)
630 return;
632 /* The operand isn't fully resolved. Determine a BFD reloc value
633 based on the operand information and leave it to
634 bfd_install_relocation. Note that this doesn't work when
635 partial_inplace == false. */
637 reloc_type = md_cgen_lookup_reloc (insn, operand, fixP);
639 if (reloc_type != BFD_RELOC_NONE)
640 fixP->fx_r_type = reloc_type;
641 else
643 as_bad_where (fixP->fx_file, fixP->fx_line,
644 _("unresolved expression that must be resolved"));
645 fixP->fx_done = 1;
646 return;
649 else if (fixP->fx_done)
651 /* We're finished with this fixup. Install it because
652 bfd_install_relocation won't be called to do it. */
653 switch (fixP->fx_r_type)
655 case BFD_RELOC_8:
656 md_number_to_chars (where, value, 1);
657 break;
658 case BFD_RELOC_16:
659 md_number_to_chars (where, value, 2);
660 break;
661 case BFD_RELOC_32:
662 md_number_to_chars (where, value, 4);
663 break;
664 case BFD_RELOC_64:
665 md_number_to_chars (where, value, 8);
666 break;
667 default:
668 as_bad_where (fixP->fx_file, fixP->fx_line,
669 _("internal error: can't install fix for reloc type %d (`%s')"),
670 fixP->fx_r_type, bfd_get_reloc_code_name (fixP->fx_r_type));
671 break;
674 /* else
675 bfd_install_relocation will be called to finish things up. */
677 /* Tuck `value' away for use by tc_gen_reloc.
678 See the comment describing fx_addnumber in write.h.
679 This field is misnamed (or misused :-). */
680 fixP->fx_addnumber = value;
683 /* Translate internal representation of relocation info to BFD target format.
685 FIXME: To what extent can we get all relevant targets to use this? */
687 arelent *
688 gas_cgen_tc_gen_reloc (section, fixP)
689 asection * section ATTRIBUTE_UNUSED;
690 fixS * fixP;
692 arelent *reloc;
694 reloc = (arelent *) xmalloc (sizeof (arelent));
696 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
697 if (reloc->howto == (reloc_howto_type *) NULL)
699 as_bad_where (fixP->fx_file, fixP->fx_line,
700 _("relocation is not supported"));
701 return NULL;
704 assert (!fixP->fx_pcrel == !reloc->howto->pc_relative);
706 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
707 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
709 /* Use fx_offset for these cases. */
710 if (fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY
711 || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT)
712 reloc->addend = fixP->fx_offset;
713 else
714 reloc->addend = fixP->fx_addnumber;
716 reloc->address = fixP->fx_frag->fr_address + fixP->fx_where;
717 return reloc;
720 /* Perform any cgen specific initialisation.
721 Called after gas_cgen_cpu_desc has been created. */
723 void
724 gas_cgen_begin ()
726 if (flag_signed_overflow_ok)
727 cgen_set_signed_overflow_ok (gas_cgen_cpu_desc);
728 else
729 cgen_clear_signed_overflow_ok (gas_cgen_cpu_desc);