/* GAS interface for targets using CGEN: Cpu tools GENerator.
- Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
+ Copyright 1996, 1997, 1998, 1999, 2000, 2001
+ Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
#include "as.h"
#include "subsegs.h"
#include "cgen.h"
+#include "dwarf2dbg.h"
/* Opcode table descriptor, must be set by md_begin. */
OPINDEX is the index in the operand table.
OPINFO is something the caller chooses to help in reloc determination. */
-struct fixup
-{
+struct fixup {
int opindex;
int opinfo;
expressionS exp;
/* We need to generate a fixup for this expression. */
if (num_fixups >= GAS_CGEN_MAX_FIXUPS)
as_fatal (_("too many fixups"));
- fixups[num_fixups].exp = * expP;
+ fixups[num_fixups].exp = *expP;
fixups[num_fixups].opindex = opindex;
fixups[num_fixups].opinfo = opinfo;
++ num_fixups;
}
-/* The following three functions allow a backup of the fixup chain to be made,
- and to have this backup be swapped with the current chain. This allows
- certain ports, eg the m32r, to swap two instructions and swap their fixups
- at the same time. */
-/* ??? I think with cgen_asm_finish_insn (or something else) there is no
- more need for this. */
+/* The following functions allow fixup chains to be stored, retrieved,
+ and swapped. They are a generalization of a pre-existing scheme
+ for storing, restoring and swapping fixup chains that was used by
+ the m32r port. The functionality is essentially the same, only
+ instead of only being able to store a single fixup chain, an entire
+ array of fixup chains can be stored. It is the user's responsibility
+ to keep track of how many fixup chains have been stored and which
+ elements of the array they are in.
+
+ The algorithms used are the same as in the old scheme. Other than the
+ "array-ness" of the whole thing, the functionality is identical to the
+ old scheme.
+
+ gas_cgen_initialize_saved_fixups_array():
+ Sets num_fixups_in_chain to 0 for each element. Call this from
+ md_begin() if you plan to use these functions and you want the
+ fixup count in each element to be set to 0 intially. This is
+ not necessary, but it's included just in case. It performs
+ the same function for each element in the array of fixup chains
+ that gas_init_parse() performs for the current fixups.
+
+ gas_cgen_save_fixups (element):
+ element - element number of the array you wish to store the fixups
+ to. No mechanism is built in for tracking what element
+ was last stored to.
+
+ gas_cgen_restore_fixups (element):
+ element - element number of the array you wish to restore the fixups
+ from.
+
+ gas_cgen_swap_fixups(int element):
+ element - swap the current fixups with those in this element number.
+*/
+
+struct saved_fixups {
+ struct fixup fixup_chain[GAS_CGEN_MAX_FIXUPS];
+ int num_fixups_in_chain;
+};
-static struct fixup saved_fixups[GAS_CGEN_MAX_FIXUPS];
-static int saved_num_fixups;
+static struct saved_fixups stored_fixups[MAX_SAVED_FIXUP_CHAINS];
-void
-gas_cgen_save_fixups ()
+void
+gas_cgen_initialize_saved_fixups_array ()
{
- saved_num_fixups = num_fixups;
-
- memcpy (saved_fixups, fixups, sizeof (fixups[0]) * num_fixups);
-
- num_fixups = 0;
+ int i = 0;
+ while (i < MAX_SAVED_FIXUP_CHAINS)
+ stored_fixups[i++].num_fixups_in_chain = 0;
}
-void
-gas_cgen_restore_fixups ()
+void
+gas_cgen_save_fixups (int i)
{
- num_fixups = saved_num_fixups;
-
- memcpy (fixups, saved_fixups, sizeof (fixups[0]) * num_fixups);
-
- saved_num_fixups = 0;
+ if (i < 0 || i >= MAX_SAVED_FIXUP_CHAINS)
+ {
+ as_fatal("index into stored_fixups[] out of bounds");
+ return;
+ }
+ stored_fixups[i].num_fixups_in_chain = num_fixups;
+ memcpy(stored_fixups[i].fixup_chain, fixups,
+ sizeof (fixups[0])*num_fixups);
+ num_fixups = 0;
}
-void
-gas_cgen_swap_fixups ()
+void
+gas_cgen_restore_fixups (int i)
{
- int tmp;
- struct fixup tmp_fixup;
-
- if (num_fixups == 0)
- {
- gas_cgen_restore_fixups ();
- }
- else if (saved_num_fixups == 0)
- {
- gas_cgen_save_fixups ();
- }
- else
- {
- tmp = saved_num_fixups;
- saved_num_fixups = num_fixups;
- num_fixups = tmp;
+ if (i < 0 || i >= MAX_SAVED_FIXUP_CHAINS)
+ {
+ as_fatal("index into stored_fixups[] out of bounds");
+ return;
+ }
+ num_fixups = stored_fixups[i].num_fixups_in_chain;
+ memcpy(fixups,stored_fixups[i].fixup_chain,
+ (sizeof (stored_fixups[i].fixup_chain[0]))*num_fixups);
+ stored_fixups[i].num_fixups_in_chain = 0;
+}
- for (tmp = GAS_CGEN_MAX_FIXUPS; tmp--;)
- {
- tmp_fixup = saved_fixups [tmp];
- saved_fixups [tmp] = fixups [tmp];
- fixups [tmp] = tmp_fixup;
- }
+void
+gas_cgen_swap_fixups (int i)
+{
+ int tmp;
+ struct fixup tmp_fixup;
+
+ if (i < 0 || i >= MAX_SAVED_FIXUP_CHAINS)
+ {
+ as_fatal("index into stored_fixups[] out of bounds");
+ return;
+ }
+
+ if (num_fixups == 0)
+ {
+ gas_cgen_restore_fixups (i);
+ }
+ else if (stored_fixups[i].num_fixups_in_chain == 0)
+ {
+ gas_cgen_save_fixups (i);
+ }
+ else
+ {
+ tmp = stored_fixups[i].num_fixups_in_chain;
+ stored_fixups[i].num_fixups_in_chain = num_fixups;
+ num_fixups = tmp;
+
+ for (tmp = GAS_CGEN_MAX_FIXUPS; tmp--;)
+ {
+ tmp_fixup = stored_fixups[i].fixup_chain [tmp];
+ stored_fixups[i].fixup_chain[tmp] = fixups [tmp];
+ fixups [tmp] = tmp_fixup;
+ }
}
}
*resultP = CGEN_PARSE_OPERAND_RESULT_REGISTER;
break;
default:
- queue_fixup (opindex, opinfo, & exp);
+ queue_fixup (opindex, opinfo, &exp);
*valueP = 0;
*resultP = CGEN_PARSE_OPERAND_RESULT_QUEUED;
break;
{
int max_len;
fragS *old_frag;
+ expressionS *exp;
+ symbolS *sym;
+ offsetT off;
#ifdef TC_CGEN_MAX_RELAX
max_len = TC_CGEN_MAX_RELAX (insn, byte_len);
/* Create a relaxable fragment for this instruction. */
old_frag = frag_now;
+ exp = &fixups[relax_operand].exp;
+ sym = exp->X_add_symbol;
+ off = exp->X_add_number;
+ if (exp->X_op != O_constant && exp->X_op != O_symbol)
+ {
+ /* Handle complex expressions. */
+ sym = make_expr_symbol (exp);
+ off = 0;
+ }
+
frag_var (rs_machine_dependent,
max_len - byte_len /* max chars */,
0 /* variable part already allocated */,
/* FIXME: When we machine generate the relax table,
machine generate a macro to compute subtype. */
1 /* subtype */,
- fixups[relax_operand].exp.X_add_symbol,
- fixups[relax_operand].exp.X_add_number,
+ sym,
+ off,
f);
/* Record the operand number with the fragment so md_convert_frag
memcpy (f, buf, byte_len);
#endif
+ /* Emit DWARF2 debugging information. */
+ dwarf2_emit_insn (byte_len);
+
/* Create any fixups. */
for (i = 0; i < num_fixups; ++i)
{
case BFD_RELOC_32:
md_number_to_chars (where, value, 4);
break;
- /* FIXME: later add support for 64 bits. */
+ case BFD_RELOC_64:
+ md_number_to_chars (where, value, 8);
+ break;
default:
as_bad_where (fixP->fx_file, fixP->fx_line,
_("internal error: can't install fix for reloc type %d (`%s')"),
if (reloc->howto == (reloc_howto_type *) NULL)
{
as_bad_where (fixP->fx_file, fixP->fx_line,
- _("internal error: can't export reloc type %d (`%s')"),
- fixP->fx_r_type, bfd_get_reloc_code_name (fixP->fx_r_type));
+ _("relocation is not supported"));
return NULL;
}