1 /* GAS interface for targets using CGEN: Cpu tools GENerator.
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001
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)
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. */
23 #include "libiberty.h"
26 #include "cgen-desc.h"
30 #include "dwarf2dbg.h"
32 /* Opcode table descriptor, must be set by md_begin. */
34 CGEN_CPU_DESC gas_cgen_cpu_desc;
36 /* Callback to insert a register into the symbol table.
37 A target may choose to let GAS parse the registers.
38 ??? Not currently used. */
41 cgen_asm_record_register (name, number)
45 /* Use symbol_create here instead of symbol_new so we don't try to
46 output registers into the object file's symbol table. */
47 symbol_table_insert (symbol_create (name, reg_section,
48 number, &zero_address_frag));
51 /* We need to keep a list of fixups. We can't simply generate them as
52 we go, because that would require us to first create the frag, and
53 that would screw up references to ``.''.
55 This is used by cpu's with simple operands. It keeps knowledge of what
56 an `expressionS' is and what a `fixup' is out of CGEN which for the time
59 OPINDEX is the index in the operand table.
60 OPINFO is something the caller chooses to help in reloc determination. */
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. */
75 gas_cgen_init_parse ()
83 queue_fixup (opindex, opinfo, 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;
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
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 intially. 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
123 gas_cgen_restore_fixups (element):
124 element - element number of the array you wish to restore the fixups
127 gas_cgen_swap_fixups(int element):
128 element - swap the current fixups with those in this element number.
131 struct saved_fixups {
132 struct fixup fixup_chain[GAS_CGEN_MAX_FIXUPS];
133 int num_fixups_in_chain;
136 static struct saved_fixups stored_fixups[MAX_SAVED_FIXUP_CHAINS];
139 gas_cgen_initialize_saved_fixups_array ()
143 while (i < MAX_SAVED_FIXUP_CHAINS)
144 stored_fixups[i++].num_fixups_in_chain = 0;
148 gas_cgen_save_fixups (i)
151 if (i < 0 || i >= MAX_SAVED_FIXUP_CHAINS)
153 as_fatal ("index into stored_fixups[] out of bounds");
157 stored_fixups[i].num_fixups_in_chain = num_fixups;
158 memcpy (stored_fixups[i].fixup_chain, fixups,
159 sizeof (fixups[0]) * num_fixups);
164 gas_cgen_restore_fixups (i)
167 if (i < 0 || i >= MAX_SAVED_FIXUP_CHAINS)
169 as_fatal ("index into stored_fixups[] out of bounds");
173 num_fixups = stored_fixups[i].num_fixups_in_chain;
174 memcpy (fixups,stored_fixups[i].fixup_chain,
175 (sizeof (stored_fixups[i].fixup_chain[0])) * num_fixups);
176 stored_fixups[i].num_fixups_in_chain = 0;
180 gas_cgen_swap_fixups (i)
183 if (i < 0 || i >= MAX_SAVED_FIXUP_CHAINS)
185 as_fatal ("index into stored_fixups[] out of bounds");
190 gas_cgen_restore_fixups (i);
192 else if (stored_fixups[i].num_fixups_in_chain == 0)
193 gas_cgen_save_fixups (i);
198 struct fixup tmp_fixup;
200 tmp = stored_fixups[i].num_fixups_in_chain;
201 stored_fixups[i].num_fixups_in_chain = num_fixups;
204 for (tmp = GAS_CGEN_MAX_FIXUPS; tmp--;)
206 tmp_fixup = stored_fixups[i].fixup_chain [tmp];
207 stored_fixups[i].fixup_chain[tmp] = fixups [tmp];
208 fixups [tmp] = tmp_fixup;
213 /* Default routine to record a fixup.
214 This is a cover function to fix_new.
215 It exists because we record INSN with the fixup.
217 FRAG and WHERE are their respective arguments to fix_new_exp.
219 OPINFO is something the caller chooses to help in reloc determination.
221 At this point we do not use a bfd_reloc_code_real_type for
222 operands residing in the insn, but instead just use the
223 operand index. This lets us easily handle fixups for any
224 operand type. We pick a BFD reloc type in md_apply_fix3. */
227 gas_cgen_record_fixup (frag, where, insn, length, operand, opinfo, symbol, offset)
230 const CGEN_INSN * insn;
232 const CGEN_OPERAND * operand;
239 /* It may seem strange to use operand->attrs and not insn->attrs here,
240 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;
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.
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_fix3. */
267 gas_cgen_record_fixup_exp (frag, where, insn, length, operand, opinfo, exp)
270 const CGEN_INSN * insn;
272 const CGEN_OPERAND * operand;
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. */
281 fixP = fix_new_exp (frag, where, length / 8, exp,
282 CGEN_OPERAND_ATTR_VALUE (operand, CGEN_OPERAND_PCREL_ADDR),
283 (bfd_reloc_code_real_type)
284 ((int) BFD_RELOC_UNUSED
285 + (int) operand->type));
286 fixP->fx_cgen.insn = insn;
287 fixP->fx_cgen.opinfo = opinfo;
292 /* Used for communication between the next two procedures. */
293 static jmp_buf expr_jmp_buf;
294 static int expr_jmp_buf_p;
296 /* Callback for cgen interface. Parse the expression at *STRP.
297 The result is an error message or NULL for success (in which case
298 *STRP is advanced past the parsed text).
299 WANT is an indication of what the caller is looking for.
300 If WANT == CGEN_ASM_PARSE_INIT the caller is beginning to try to match
301 a table entry with the insn, reset the queued fixups counter.
302 An enum cgen_parse_operand_result is stored in RESULTP.
303 OPINDEX is the operand's table entry index.
304 OPINFO is something the caller chooses to help in reloc determination.
305 The resulting value is stored in VALUEP. */
308 gas_cgen_parse_operand (cd, want, strP, opindex, opinfo, resultP, valueP)
309 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED;
310 enum cgen_parse_operand_type want;
314 enum cgen_parse_operand_result *resultP;
318 /* These are volatile to survive the setjmp. */
319 char * volatile hold;
320 enum cgen_parse_operand_result * volatile resultP_1;
323 static enum cgen_parse_operand_result *resultP_1;
325 const char *errmsg = NULL;
328 if (want == CGEN_PARSE_OPERAND_INIT)
330 gas_cgen_init_parse ();
335 hold = input_line_pointer;
336 input_line_pointer = (char *) *strP;
338 /* We rely on md_operand to longjmp back to us.
339 This is done via gas_cgen_md_operand. */
340 if (setjmp (expr_jmp_buf) != 0)
343 input_line_pointer = (char *) hold;
344 *resultP_1 = CGEN_PARSE_OPERAND_RESULT_ERROR;
345 return _("illegal operand");
352 *strP = input_line_pointer;
353 input_line_pointer = hold;
355 /* FIXME: Need to check `want'. */
360 errmsg = _("illegal operand");
361 *resultP = CGEN_PARSE_OPERAND_RESULT_ERROR;
364 errmsg = _("missing operand");
365 *resultP = CGEN_PARSE_OPERAND_RESULT_ERROR;
368 *valueP = exp.X_add_number;
369 *resultP = CGEN_PARSE_OPERAND_RESULT_NUMBER;
372 *valueP = exp.X_add_number;
373 *resultP = CGEN_PARSE_OPERAND_RESULT_REGISTER;
376 queue_fixup (opindex, opinfo, &exp);
378 *resultP = CGEN_PARSE_OPERAND_RESULT_QUEUED;
385 /* md_operand handler to catch unrecognized expressions and halt the
386 parsing process so the next entry can be tried.
388 ??? This could be done differently by adding code to `expression'. */
391 gas_cgen_md_operand (expressionP)
392 expressionS *expressionP ATTRIBUTE_UNUSED;
394 /* Don't longjmp if we're not called from within cgen_parse_operand(). */
396 longjmp (expr_jmp_buf, 1);
399 /* Finish assembling instruction INSN.
400 BUF contains what we've built up so far.
401 LENGTH is the size of the insn in bits.
402 RELAX_P is non-zero if relaxable insns should be emitted as such.
403 Otherwise they're emitted in non-relaxable forms.
404 The "result" is stored in RESULT if non-NULL. */
407 gas_cgen_finish_insn (insn, buf, length, relax_p, result)
408 const CGEN_INSN *insn;
409 CGEN_INSN_BYTES_PTR buf;
412 finished_insnS *result;
417 unsigned int byte_len = length / 8;
419 /* ??? Target foo issues various warnings here, so one might want to provide
420 a hook here. However, our caller is defined in tc-foo.c so there
421 shouldn't be a need for a hook. */
423 /* Write out the instruction.
424 It is important to fetch enough space in one call to `frag_more'.
425 We use (f - frag_now->fr_literal) to compute where we are and we
426 don't want frag_now to change between calls.
428 Relaxable instructions: We need to ensure we allocate enough
429 space for the largest insn. */
431 if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAX))
432 /* These currently shouldn't get here. */
435 /* Is there a relaxable insn with the relaxable operand needing a fixup? */
438 if (relax_p && CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXABLE))
440 /* Scan the fixups for the operand affected by relaxing
441 (i.e. the branch address). */
443 for (i = 0; i < num_fixups; ++i)
445 if (CGEN_OPERAND_ATTR_VALUE (cgen_operand_lookup_by_num (gas_cgen_cpu_desc, fixups[i].opindex),
454 if (relax_operand != -1)
462 #ifdef TC_CGEN_MAX_RELAX
463 max_len = TC_CGEN_MAX_RELAX (insn, byte_len);
465 max_len = CGEN_MAX_INSN_SIZE;
467 /* Ensure variable part and fixed part are in same fragment. */
468 /* FIXME: Having to do this seems like a hack. */
471 /* Allocate space for the fixed part. */
472 f = frag_more (byte_len);
474 /* Create a relaxable fragment for this instruction. */
477 exp = &fixups[relax_operand].exp;
478 sym = exp->X_add_symbol;
479 off = exp->X_add_number;
480 if (exp->X_op != O_constant && exp->X_op != O_symbol)
482 /* Handle complex expressions. */
483 sym = make_expr_symbol (exp);
487 frag_var (rs_machine_dependent,
488 max_len - byte_len /* max chars */,
489 0 /* variable part already allocated */,
490 /* FIXME: When we machine generate the relax table,
491 machine generate a macro to compute subtype. */
497 /* Record the operand number with the fragment so md_convert_frag
498 can use gas_cgen_md_record_fixup to record the appropriate reloc. */
499 old_frag->fr_cgen.insn = insn;
500 old_frag->fr_cgen.opindex = fixups[relax_operand].opindex;
501 old_frag->fr_cgen.opinfo = fixups[relax_operand].opinfo;
503 result->frag = old_frag;
507 f = frag_more (byte_len);
509 result->frag = frag_now;
512 /* If we're recording insns as numbers (rather than a string of bytes),
513 target byte order handling is deferred until now. */
515 cgen_put_insn_value (gas_cgen_cpu_desc, f, length, *buf);
517 memcpy (f, buf, byte_len);
520 /* Emit DWARF2 debugging information. */
521 dwarf2_emit_insn (byte_len);
523 /* Create any fixups. */
524 for (i = 0; i < num_fixups; ++i)
527 const CGEN_OPERAND *operand =
528 cgen_operand_lookup_by_num (gas_cgen_cpu_desc, fixups[i].opindex);
530 /* Don't create fixups for these. That's done during relaxation.
531 We don't need to test for CGEN_INSN_RELAX as they can't get here
534 && CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXABLE)
535 && CGEN_OPERAND_ATTR_VALUE (operand, CGEN_OPERAND_RELAX))
538 #ifndef md_cgen_record_fixup_exp
539 #define md_cgen_record_fixup_exp gas_cgen_record_fixup_exp
542 fixP = md_cgen_record_fixup_exp (frag_now, f - frag_now->fr_literal,
543 insn, length, operand,
547 result->fixups[i] = fixP;
552 result->num_fixups = num_fixups;
557 /* Apply a fixup to the object code. This is called for all the
558 fixups we generated by the call to fix_new_exp, above. In the call
559 above we used a reloc code which was the largest legal reloc code
560 plus the operand index. Here we undo that to recover the operand
561 index. At this point all symbol values should be fully resolved,
562 and we attempt to completely resolve the reloc. If we can not do
563 that, we determine the correct reloc code and put it back in the fixup. */
565 /* FIXME: This function handles some of the fixups and bfd_install_relocation
566 handles the rest. bfd_install_relocation (or some other bfd function)
567 should handle them all. */
570 gas_cgen_md_apply_fix3 (fixP, valP, seg)
573 segT seg ATTRIBUTE_UNUSED;
575 char *where = fixP->fx_frag->fr_literal + fixP->fx_where;
576 valueT value = * valP;
577 /* Canonical name, since used a lot. */
578 CGEN_CPU_DESC cd = gas_cgen_cpu_desc;
580 /* FIXME FIXME FIXME: The value we are passed in *valuep includes
581 the symbol values. Since we are using BFD_ASSEMBLER, if we are
582 doing this relocation the code in write.c is going to call
583 bfd_install_relocation, which is also going to use the symbol
584 value. That means that if the reloc is fully resolved we want to
585 use *valuep since bfd_install_relocation is not being used.
586 However, if the reloc is not fully resolved we do not want to use
587 *valuep, and must use fx_offset instead. However, if the reloc
588 is PC relative, we do want to use *valuep since it includes the
589 result of md_pcrel_from. This is confusing. */
591 if (fixP->fx_addsy == (symbolS *) NULL)
594 else if (fixP->fx_pcrel)
599 value = fixP->fx_offset;
601 if (fixP->fx_subsy != (symbolS *) NULL)
603 if (S_GET_SEGMENT (fixP->fx_subsy) == absolute_section)
604 value -= S_GET_VALUE (fixP->fx_subsy);
607 /* We don't actually support subtracting a symbol. */
608 as_bad_where (fixP->fx_file, fixP->fx_line,
609 _("expression too complex"));
614 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
616 int opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
617 const CGEN_OPERAND *operand = cgen_operand_lookup_by_num (cd, opindex);
619 bfd_reloc_code_real_type reloc_type;
620 CGEN_FIELDS *fields = alloca (CGEN_CPU_SIZEOF_FIELDS (cd));
621 const CGEN_INSN *insn = fixP->fx_cgen.insn;
623 /* If the reloc has been fully resolved finish the operand here. */
624 /* FIXME: This duplicates the capabilities of code in BFD. */
626 /* FIXME: If partial_inplace isn't set bfd_install_relocation won't
627 finish the job. Testing for pcrel is a temporary hack. */
630 CGEN_CPU_SET_FIELDS_BITSIZE (cd) (fields, CGEN_INSN_BITSIZE (insn));
631 CGEN_CPU_SET_VMA_OPERAND (cd) (cd, opindex, fields, (bfd_vma) value);
635 CGEN_INSN_INT insn_value =
636 cgen_get_insn_value (cd, where, CGEN_INSN_BITSIZE (insn));
638 /* ??? 0 is passed for `pc'. */
639 errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields,
640 &insn_value, (bfd_vma) 0);
641 cgen_put_insn_value (cd, where, CGEN_INSN_BITSIZE (insn),
645 /* ??? 0 is passed for `pc'. */
646 errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields, where,
650 as_bad_where (fixP->fx_file, fixP->fx_line, "%s", errmsg);
656 /* The operand isn't fully resolved. Determine a BFD reloc value
657 based on the operand information and leave it to
658 bfd_install_relocation. Note that this doesn't work when
659 partial_inplace == false. */
661 reloc_type = md_cgen_lookup_reloc (insn, operand, fixP);
663 if (reloc_type != BFD_RELOC_NONE)
664 fixP->fx_r_type = reloc_type;
667 as_bad_where (fixP->fx_file, fixP->fx_line,
668 _("unresolved expression that must be resolved"));
673 else if (fixP->fx_done)
675 /* We're finished with this fixup. Install it because
676 bfd_install_relocation won't be called to do it. */
677 switch (fixP->fx_r_type)
680 md_number_to_chars (where, value, 1);
683 md_number_to_chars (where, value, 2);
686 md_number_to_chars (where, value, 4);
689 md_number_to_chars (where, value, 8);
692 as_bad_where (fixP->fx_file, fixP->fx_line,
693 _("internal error: can't install fix for reloc type %d (`%s')"),
694 fixP->fx_r_type, bfd_get_reloc_code_name (fixP->fx_r_type));
699 bfd_install_relocation will be called to finish things up. */
701 /* Tuck `value' away for use by tc_gen_reloc.
702 See the comment describing fx_addnumber in write.h.
703 This field is misnamed (or misused :-). */
704 fixP->fx_addnumber = value;
707 /* Translate internal representation of relocation info to BFD target format.
709 FIXME: To what extent can we get all relevant targets to use this? */
712 gas_cgen_tc_gen_reloc (section, fixP)
713 asection * section ATTRIBUTE_UNUSED;
718 reloc = (arelent *) xmalloc (sizeof (arelent));
720 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
721 if (reloc->howto == (reloc_howto_type *) NULL)
723 as_bad_where (fixP->fx_file, fixP->fx_line,
724 _("relocation is not supported"));
728 assert (!fixP->fx_pcrel == !reloc->howto->pc_relative);
730 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
731 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
733 /* Use fx_offset for these cases. */
734 if (fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY
735 || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT)
736 reloc->addend = fixP->fx_offset;
738 reloc->addend = fixP->fx_addnumber;
740 reloc->address = fixP->fx_frag->fr_address + fixP->fx_where;