1 /* GAS interface for targets using CGEN: Cpu tools GENerator.
2 Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
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)
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.
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. */
22 #include "libiberty.h"
25 #include "cgen-desc.h"
30 /* Opcode table descriptor, must be set by md_begin. */
32 CGEN_CPU_DESC gas_cgen_cpu_desc;
34 /* Callback to insert a register into the symbol table.
35 A target may choose to let GAS parse the registers.
36 ??? Not currently used. */
39 cgen_asm_record_register (name, number)
43 /* Use symbol_create here instead of symbol_new so we don't try to
44 output registers into the object file's symbol table. */
45 symbol_table_insert (symbol_create (name, reg_section,
46 number, & zero_address_frag));
49 /* We need to keep a list of fixups. We can't simply generate them as
50 we go, because that would require us to first create the frag, and
51 that would screw up references to ``.''.
53 This is used by cpu's with simple operands. It keeps knowledge of what
54 an `expressionS' is and what a `fixup' is out of CGEN which for the time
57 OPINDEX is the index in the operand table.
58 OPINFO is something the caller chooses to help in reloc determination. */
67 static struct fixup fixups [GAS_CGEN_MAX_FIXUPS];
68 static int num_fixups;
70 /* Prepare to parse an instruction.
71 ??? May wish to make this static and delete calls in md_assemble. */
74 gas_cgen_init_parse ()
82 queue_fixup (opindex, opinfo, expP)
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;
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
100 /* ??? I think with cgen_asm_finish_insn (or something else) there is no
101 more need for this. */
103 static struct fixup saved_fixups [GAS_CGEN_MAX_FIXUPS];
104 static int saved_num_fixups;
107 gas_cgen_save_fixups ()
109 saved_num_fixups = num_fixups;
111 memcpy (saved_fixups, fixups, sizeof (fixups[0]) * num_fixups);
117 gas_cgen_restore_fixups ()
119 num_fixups = saved_num_fixups;
121 memcpy (fixups, saved_fixups, sizeof (fixups[0]) * num_fixups);
123 saved_num_fixups = 0;
127 gas_cgen_swap_fixups ()
130 struct fixup tmp_fixup;
134 gas_cgen_restore_fixups ();
136 else if (saved_num_fixups == 0)
138 gas_cgen_save_fixups ();
142 tmp = saved_num_fixups;
143 saved_num_fixups = num_fixups;
146 for (tmp = GAS_CGEN_MAX_FIXUPS; tmp--;)
148 tmp_fixup = saved_fixups [tmp];
149 saved_fixups [tmp] = fixups [tmp];
150 fixups [tmp] = tmp_fixup;
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.
159 FRAG and WHERE are their respective arguments to fix_new_exp.
161 OPINFO is something the caller chooses to help in reloc determination.
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. */
169 gas_cgen_record_fixup (frag, where, insn, length, operand, opinfo, symbol, offset)
172 const CGEN_INSN * insn;
174 const CGEN_OPERAND * operand;
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. */
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;
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.
199 FRAG and WHERE are their respective arguments to fix_new_exp.
201 OPINFO is something the caller chooses to help in reloc determination.
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. */
209 gas_cgen_record_fixup_exp (frag, where, insn, length, operand, opinfo, exp)
212 const CGEN_INSN * insn;
214 const CGEN_OPERAND * operand;
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. */
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;
234 /* Used for communication between the next two procedures. */
235 static jmp_buf expr_jmp_buf;
236 static int expr_jmp_buf_p;
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. */
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;
256 enum cgen_parse_operand_result * resultP;
260 /* These are volatile to survive the setjmp. */
261 char * volatile hold;
262 enum cgen_parse_operand_result * volatile resultP_1;
265 static enum cgen_parse_operand_result * resultP_1;
267 const char * errmsg = NULL;
270 if (want == CGEN_PARSE_OPERAND_INIT)
272 gas_cgen_init_parse ();
277 hold = input_line_pointer;
278 input_line_pointer = (char *) * strP;
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)
285 input_line_pointer = (char *) hold;
286 * resultP_1 = CGEN_PARSE_OPERAND_RESULT_ERROR;
287 return "illegal operand";
294 * strP = input_line_pointer;
295 input_line_pointer = hold;
297 /* FIXME: Need to check `want'. */
302 errmsg = _("illegal operand");
303 * resultP = CGEN_PARSE_OPERAND_RESULT_ERROR;
306 errmsg = _("missing operand");
307 * resultP = CGEN_PARSE_OPERAND_RESULT_ERROR;
310 * valueP = exp.X_add_number;
311 * resultP = CGEN_PARSE_OPERAND_RESULT_NUMBER;
314 * valueP = exp.X_add_number;
315 * resultP = CGEN_PARSE_OPERAND_RESULT_REGISTER;
318 queue_fixup (opindex, opinfo, & exp);
320 * resultP = CGEN_PARSE_OPERAND_RESULT_QUEUED;
327 /* md_operand handler to catch unrecognized expressions and halt the
328 parsing process so the next entry can be tried.
330 ??? This could be done differently by adding code to `expression'. */
333 gas_cgen_md_operand (expressionP)
334 expressionS * expressionP ATTRIBUTE_UNUSED;
336 /* Don't longjmp if we're not called from within cgen_parse_operand(). */
338 longjmp (expr_jmp_buf, 1);
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. */
349 gas_cgen_finish_insn (insn, buf, length, relax_p, result)
350 const CGEN_INSN * insn;
351 CGEN_INSN_BYTES_PTR buf;
354 finished_insnS * result;
359 unsigned int byte_len = length / 8;
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. */
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.
370 Relaxable instructions: We need to ensure we allocate enough
371 space for the largest insn. */
373 if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAX))
374 abort (); /* These currently shouldn't get here. */
376 /* Is there a relaxable insn with the relaxable operand needing a fixup? */
379 if (relax_p && CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXABLE))
381 /* Scan the fixups for the operand affected by relaxing
382 (i.e. the branch address). */
384 for (i = 0; i < num_fixups; ++ i)
386 if (CGEN_OPERAND_ATTR_VALUE (cgen_operand_lookup_by_num (gas_cgen_cpu_desc, fixups[i].opindex),
395 if (relax_operand != -1)
400 #ifdef TC_CGEN_MAX_RELAX
401 max_len = TC_CGEN_MAX_RELAX (insn, byte_len);
403 max_len = CGEN_MAX_INSN_SIZE;
405 /* Ensure variable part and fixed part are in same fragment. */
406 /* FIXME: Having to do this seems like a hack. */
409 /* Allocate space for the fixed part. */
410 f = frag_more (byte_len);
412 /* Create a relaxable fragment for this instruction. */
415 frag_var (rs_machine_dependent,
416 max_len - byte_len /* max chars */,
417 0 /* variable part already allocated */,
418 /* FIXME: When we machine generate the relax table,
419 machine generate a macro to compute subtype. */
421 fixups[relax_operand].exp.X_add_symbol,
422 fixups[relax_operand].exp.X_add_number,
425 /* Record the operand number with the fragment so md_convert_frag
426 can use gas_cgen_md_record_fixup to record the appropriate reloc. */
427 old_frag->fr_cgen.insn = insn;
428 old_frag->fr_cgen.opindex = fixups[relax_operand].opindex;
429 old_frag->fr_cgen.opinfo = fixups[relax_operand].opinfo;
431 result->frag = old_frag;
435 f = frag_more (byte_len);
437 result->frag = frag_now;
440 /* If we're recording insns as numbers (rather than a string of bytes),
441 target byte order handling is deferred until now. */
443 cgen_put_insn_value (gas_cgen_cpu_desc, f, length, *buf);
445 memcpy (f, buf, byte_len);
448 /* Create any fixups. */
449 for (i = 0; i < num_fixups; ++i)
452 const CGEN_OPERAND *operand =
453 cgen_operand_lookup_by_num (gas_cgen_cpu_desc, fixups[i].opindex);
455 /* Don't create fixups for these. That's done during relaxation.
456 We don't need to test for CGEN_INSN_RELAX as they can't get here
459 && CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXABLE)
460 && CGEN_OPERAND_ATTR_VALUE (operand, CGEN_OPERAND_RELAX))
463 #ifndef md_cgen_record_fixup_exp
464 #define md_cgen_record_fixup_exp gas_cgen_record_fixup_exp
467 fixP = md_cgen_record_fixup_exp (frag_now, f - frag_now->fr_literal,
468 insn, length, operand,
472 result->fixups[i] = fixP;
477 result->num_fixups = num_fixups;
482 /* Apply a fixup to the object code. This is called for all the
483 fixups we generated by the call to fix_new_exp, above. In the call
484 above we used a reloc code which was the largest legal reloc code
485 plus the operand index. Here we undo that to recover the operand
486 index. At this point all symbol values should be fully resolved,
487 and we attempt to completely resolve the reloc. If we can not do
488 that, we determine the correct reloc code and put it back in the fixup. */
490 /* FIXME: This function handles some of the fixups and bfd_install_relocation
491 handles the rest. bfd_install_relocation (or some other bfd function)
492 should handle them all. */
495 gas_cgen_md_apply_fix3 (fixP, valueP, seg)
498 segT seg ATTRIBUTE_UNUSED;
500 char * where = fixP->fx_frag->fr_literal + fixP->fx_where;
502 /* canonical name, since used a lot */
503 CGEN_CPU_DESC cd = gas_cgen_cpu_desc;
505 /* FIXME FIXME FIXME: The value we are passed in *valuep includes
506 the symbol values. Since we are using BFD_ASSEMBLER, if we are
507 doing this relocation the code in write.c is going to call
508 bfd_install_relocation, which is also going to use the symbol
509 value. That means that if the reloc is fully resolved we want to
510 use *valuep since bfd_install_relocation is not being used.
511 However, if the reloc is not fully resolved we do not want to use
512 *valuep, and must use fx_offset instead. However, if the reloc
513 is PC relative, we do want to use *valuep since it includes the
514 result of md_pcrel_from. This is confusing. */
516 if (fixP->fx_addsy == (symbolS *) NULL)
521 else if (fixP->fx_pcrel)
525 value = fixP->fx_offset;
526 if (fixP->fx_subsy != (symbolS *) NULL)
528 if (S_GET_SEGMENT (fixP->fx_subsy) == absolute_section)
529 value -= S_GET_VALUE (fixP->fx_subsy);
532 /* We don't actually support subtracting a symbol. */
533 as_bad_where (fixP->fx_file, fixP->fx_line,
534 _("expression too complex"));
539 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
541 int opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
542 const CGEN_OPERAND *operand = cgen_operand_lookup_by_num (cd, opindex);
544 bfd_reloc_code_real_type reloc_type;
545 CGEN_FIELDS *fields = alloca (CGEN_CPU_SIZEOF_FIELDS (cd));
546 const CGEN_INSN *insn = fixP->fx_cgen.insn;
548 /* If the reloc has been fully resolved finish the operand here. */
549 /* FIXME: This duplicates the capabilities of code in BFD. */
551 /* FIXME: If partial_inplace isn't set bfd_install_relocation won't
552 finish the job. Testing for pcrel is a temporary hack. */
555 CGEN_CPU_SET_FIELDS_BITSIZE (cd) (fields, CGEN_INSN_BITSIZE (insn));
556 CGEN_CPU_SET_VMA_OPERAND (cd) (cd, opindex, fields, (bfd_vma) value);
560 CGEN_INSN_INT insn_value =
561 cgen_get_insn_value (cd, where, CGEN_INSN_BITSIZE (insn));
563 /* ??? 0 is passed for `pc' */
564 errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields,
565 &insn_value, (bfd_vma) 0);
566 cgen_put_insn_value (cd, where, CGEN_INSN_BITSIZE (insn),
570 /* ??? 0 is passed for `pc' */
571 errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields, where,
575 as_bad_where (fixP->fx_file, fixP->fx_line, "%s", errmsg);
581 /* The operand isn't fully resolved. Determine a BFD reloc value
582 based on the operand information and leave it to
583 bfd_install_relocation. Note that this doesn't work when
584 partial_inplace == false. */
586 reloc_type = md_cgen_lookup_reloc (insn, operand, fixP);
587 if (reloc_type != BFD_RELOC_NONE)
589 fixP->fx_r_type = reloc_type;
593 as_bad_where (fixP->fx_file, fixP->fx_line,
594 _("unresolved expression that must be resolved"));
599 else if (fixP->fx_done)
601 /* We're finished with this fixup. Install it because
602 bfd_install_relocation won't be called to do it. */
603 switch (fixP->fx_r_type)
606 md_number_to_chars (where, value, 1);
609 md_number_to_chars (where, value, 2);
612 md_number_to_chars (where, value, 4);
614 /* FIXME: later add support for 64 bits. */
616 as_bad_where (fixP->fx_file, fixP->fx_line,
617 _("internal error: can't install fix for reloc type %d (`%s')"),
618 fixP->fx_r_type, bfd_get_reloc_code_name (fixP->fx_r_type));
624 /* bfd_install_relocation will be called to finish things up. */
627 /* Tuck `value' away for use by tc_gen_reloc.
628 See the comment describing fx_addnumber in write.h.
629 This field is misnamed (or misused :-). */
630 fixP->fx_addnumber = value;
635 /* Translate internal representation of relocation info to BFD target format.
637 FIXME: To what extent can we get all relevant targets to use this? */
640 gas_cgen_tc_gen_reloc (section, fixP)
641 asection * section ATTRIBUTE_UNUSED;
646 reloc = (arelent *) xmalloc (sizeof (arelent));
648 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
649 if (reloc->howto == (reloc_howto_type *) NULL)
651 as_bad_where (fixP->fx_file, fixP->fx_line,
652 _("internal error: can't export reloc type %d (`%s')"),
653 fixP->fx_r_type, bfd_get_reloc_code_name (fixP->fx_r_type));
657 assert (!fixP->fx_pcrel == !reloc->howto->pc_relative);
659 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
660 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
662 /* Use fx_offset for these cases */
663 if ( fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY
664 || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT)
665 reloc->addend = fixP->fx_offset;
667 reloc->addend = fixP->fx_addnumber;
669 reloc->address = fixP->fx_frag->fr_address + fixP->fx_where;