1 /* GAS interface for targets using CGEN: Cpu tools GENerator.
2 Copyright (C) 1996, 1997, 1998 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. */
29 /* Callback to insert a register into the symbol table.
30 A target may choose to let GAS parse the registers.
31 ??? Not currently used. */
34 cgen_asm_record_register (name
, number
)
38 /* Use symbol_create here instead of symbol_new so we don't try to
39 output registers into the object file's symbol table. */
40 symbol_table_insert (symbol_create (name
, reg_section
,
41 number
, & zero_address_frag
));
44 /* We need to keep a list of fixups. We can't simply generate them as
45 we go, because that would require us to first create the frag, and
46 that would screw up references to ``.''.
48 This is used by cpu's with simple operands. It keeps knowledge of what
49 an `expressionS' is and what a `fixup' is out of CGEN which for the time
52 OPINDEX is the index in the operand table.
53 OPINFO is something the caller chooses to help in reloc determination. */
62 static struct fixup fixups
[CGEN_MAX_FIXUPS
];
63 static int num_fixups
;
65 /* Prepare to parse an instruction.
66 ??? May wish to make this static and delete calls in md_assemble. */
69 cgen_asm_init_parse ()
77 cgen_queue_fixup (opindex
, opinfo
, expP
)
81 /* We need to generate a fixup for this expression. */
82 if (num_fixups
>= CGEN_MAX_FIXUPS
)
83 as_fatal (_("too many fixups"));
84 fixups
[num_fixups
].exp
= * expP
;
85 fixups
[num_fixups
].opindex
= opindex
;
86 fixups
[num_fixups
].opinfo
= opinfo
;
90 /* The following three functions allow a backup of the fixup chain to be made,
91 and to have this backup be swapped with the current chain. This allows
92 certain ports, eg the m32r, to swap two instructions and swap their fixups
94 static struct fixup saved_fixups
[CGEN_MAX_FIXUPS
];
95 static int saved_num_fixups
;
100 saved_num_fixups
= num_fixups
;
102 memcpy (saved_fixups
, fixups
, sizeof (fixups
[0]) * num_fixups
);
108 cgen_restore_fixups ()
110 num_fixups
= saved_num_fixups
;
112 memcpy (fixups
, saved_fixups
, sizeof (fixups
[0]) * num_fixups
);
114 saved_num_fixups
= 0;
121 struct fixup tmp_fixup
;
125 cgen_restore_fixups ();
127 else if (saved_num_fixups
== 0)
133 tmp
= saved_num_fixups
;
134 saved_num_fixups
= num_fixups
;
137 for (tmp
= CGEN_MAX_FIXUPS
; tmp
--;)
139 tmp_fixup
= saved_fixups
[tmp
];
140 saved_fixups
[tmp
] = fixups
[tmp
];
141 fixups
[tmp
] = tmp_fixup
;
146 /* Default routine to record a fixup.
147 This is a cover function to fix_new.
148 It exists because we record INSN with the fixup.
150 FRAG and WHERE are their respective arguments to fix_new_exp.
152 OPINFO is something the caller chooses to help in reloc determination.
154 At this point we do not use a bfd_reloc_code_real_type for
155 operands residing in the insn, but instead just use the
156 operand index. This lets us easily handle fixups for any
157 operand type. We pick a BFD reloc type in md_apply_fix. */
160 cgen_record_fixup (frag
, where
, insn
, length
, operand
, opinfo
, symbol
, offset
)
163 const CGEN_INSN
* insn
;
165 const CGEN_OPERAND
* operand
;
172 /* It may seem strange to use operand->attrs and not insn->attrs here,
173 but it is the operand that has a pc relative relocation. */
175 fixP
= fix_new (frag
, where
, length
/ 8, symbol
, offset
,
176 CGEN_OPERAND_ATTR (operand
, CGEN_OPERAND_PCREL_ADDR
) != 0,
177 (bfd_reloc_code_real_type
) ((int) BFD_RELOC_UNUSED
+ CGEN_OPERAND_INDEX (operand
)));
178 fixP
->tc_fix_data
.insn
= (PTR
) insn
;
179 fixP
->tc_fix_data
.opinfo
= opinfo
;
184 /* Default routine to record a fixup given an expression.
185 This is a cover function to fix_new_exp.
186 It exists because we record INSN with the fixup.
188 FRAG and WHERE are their respective arguments to fix_new_exp.
190 OPINFO is something the caller chooses to help in reloc determination.
192 At this point we do not use a bfd_reloc_code_real_type for
193 operands residing in the insn, but instead just use the
194 operand index. This lets us easily handle fixups for any
195 operand type. We pick a BFD reloc type in md_apply_fix. */
198 cgen_record_fixup_exp (frag
, where
, insn
, length
, operand
, opinfo
, exp
)
201 const CGEN_INSN
* insn
;
203 const CGEN_OPERAND
* operand
;
209 /* It may seem strange to use operand->attrs and not insn->attrs here,
210 but it is the operand that has a pc relative relocation. */
212 fixP
= fix_new_exp (frag
, where
, length
/ 8, exp
,
213 CGEN_OPERAND_ATTR (operand
, CGEN_OPERAND_PCREL_ADDR
) != 0,
214 (bfd_reloc_code_real_type
) ((int) BFD_RELOC_UNUSED
+ CGEN_OPERAND_INDEX (operand
)));
215 fixP
->tc_fix_data
.insn
= (PTR
) insn
;
216 fixP
->tc_fix_data
.opinfo
= opinfo
;
221 /* Used for communication between the next two procedures. */
222 static jmp_buf expr_jmp_buf
;
224 /* Callback for cgen interface. Parse the expression at *STRP.
225 The result is an error message or NULL for success (in which case
226 *STRP is advanced past the parsed text).
227 WANT is an indication of what the caller is looking for.
228 If WANT == CGEN_ASM_PARSE_INIT the caller is beginning to try to match
229 a table entry with the insn, reset the queued fixups counter.
230 An enum cgen_parse_operand_result is stored in RESULTP.
231 OPINDEX is the operand's table entry index.
232 OPINFO is something the caller chooses to help in reloc determination.
233 The resulting value is stored in VALUEP. */
236 cgen_parse_operand (want
, strP
, opindex
, opinfo
, resultP
, valueP
)
237 enum cgen_parse_operand_type want
;
241 enum cgen_parse_operand_result
* resultP
;
245 /* These are volatile to survive the setjmp. */
246 char * volatile hold
;
247 enum cgen_parse_operand_result
* volatile resultP_1
;
250 static enum cgen_parse_operand_result
* resultP_1
;
252 const char * errmsg
= NULL
;
255 if (want
== CGEN_PARSE_OPERAND_INIT
)
257 cgen_asm_init_parse ();
262 hold
= input_line_pointer
;
263 input_line_pointer
= (char *) * strP
;
265 /* We rely on md_operand to longjmp back to us.
266 This is done via cgen_md_operand. */
267 if (setjmp (expr_jmp_buf
) != 0)
269 input_line_pointer
= (char *) hold
;
270 * resultP_1
= CGEN_PARSE_OPERAND_RESULT_ERROR
;
271 return "illegal operand";
276 * strP
= input_line_pointer
;
277 input_line_pointer
= hold
;
279 /* FIXME: Need to check `want'. */
284 errmsg
= _("illegal operand");
285 * resultP
= CGEN_PARSE_OPERAND_RESULT_ERROR
;
288 errmsg
= _("missing operand");
289 * resultP
= CGEN_PARSE_OPERAND_RESULT_ERROR
;
292 * valueP
= exp
.X_add_number
;
293 * resultP
= CGEN_PARSE_OPERAND_RESULT_NUMBER
;
296 * valueP
= exp
.X_add_number
;
297 * resultP
= CGEN_PARSE_OPERAND_RESULT_REGISTER
;
300 cgen_queue_fixup (opindex
, opinfo
, & exp
);
302 * resultP
= CGEN_PARSE_OPERAND_RESULT_QUEUED
;
309 /* md_operand handler to catch unrecognized expressions and halt the
310 parsing process so the next entry can be tried.
312 ??? This could be done differently by adding code to `expression'. */
315 cgen_md_operand (expressionP
)
316 expressionS
* expressionP
;
318 longjmp (expr_jmp_buf
, 1);
321 /* Finish assembling instruction INSN.
322 BUF contains what we've built up so far.
323 LENGTH is the size of the insn in bits.
324 RELAX_P is non-zero if relaxable insns should be emitted as such.
325 Otherwise they're emitted in non-relaxable forms.
326 The "result" is stored in RESULT if non-NULL.
327 Returns the address of the buffer containing the assembled instruction,
328 in case the caller needs to modify it for some reason. */
331 cgen_asm_finish_insn (insn
, buf
, length
, relax_p
, result
)
332 const CGEN_INSN
* insn
;
336 finished_insnS
* result
;
341 unsigned int byte_len
= length
/ 8;
343 /* ??? Target foo issues various warnings here, so one might want to provide
344 a hook here. However, our caller is defined in tc-foo.c so there
345 shouldn't be a need for a hook. */
347 /* Write out the instruction.
348 It is important to fetch enough space in one call to `frag_more'.
349 We use (f - frag_now->fr_literal) to compute where we are and we
350 don't want frag_now to change between calls.
352 Relaxable instructions: We need to ensure we allocate enough
353 space for the largest insn. */
355 if (CGEN_INSN_ATTR (insn
, CGEN_INSN_RELAX
) != 0)
356 abort (); /* These currently shouldn't get here. */
358 /* Is there a relaxable insn with the relaxable operand needing a fixup? */
361 if (relax_p
&& CGEN_INSN_ATTR (insn
, CGEN_INSN_RELAXABLE
) != 0)
363 /* Scan the fixups for the operand affected by relaxing
364 (i.e. the branch address). */
366 for (i
= 0; i
< num_fixups
; ++ i
)
368 if (CGEN_OPERAND_ATTR (& CGEN_SYM (operand_table
) [fixups
[i
].opindex
],
369 CGEN_OPERAND_RELAX
) != 0)
377 if (relax_operand
!= -1)
382 #ifdef TC_CGEN_MAX_RELAX
383 max_len
= TC_CGEN_MAX_RELAX (insn
, byte_len
);
385 max_len
= CGEN_MAX_INSN_SIZE
;
387 /* Ensure variable part and fixed part are in same fragment. */
388 /* FIXME: Having to do this seems like a hack. */
391 /* Allocate space for the fixed part. */
392 f
= frag_more (byte_len
);
394 /* Create a relaxable fragment for this instruction. */
397 frag_var (rs_machine_dependent
,
398 max_len
- byte_len
/* max chars */,
399 0 /* variable part already allocated */,
400 /* FIXME: When we machine generate the relax table,
401 machine generate a macro to compute subtype. */
403 fixups
[relax_operand
].exp
.X_add_symbol
,
404 fixups
[relax_operand
].exp
.X_add_number
,
407 /* Record the operand number with the fragment so md_convert_frag
408 can use cgen_md_record_fixup to record the appropriate reloc. */
409 old_frag
->fr_cgen
.insn
= insn
;
410 old_frag
->fr_cgen
.opindex
= fixups
[relax_operand
].opindex
;
411 old_frag
->fr_cgen
.opinfo
= fixups
[relax_operand
].opinfo
;
413 result
->frag
= old_frag
;
417 f
= frag_more (byte_len
);
419 result
->frag
= frag_now
;
422 /* If we're recording insns as numbers (rather than a string of bytes),
423 target byte order handling is deferred until now. */
424 #if 0 /*def CGEN_INT_INSN*/
428 if (cgen_big_endian_p
)
429 bfd_putb16 ((bfd_vma
) * buf
, f
);
431 bfd_putl16 ((bfd_vma
) * buf
, f
);
434 if (cgen_big_endian_p
)
435 bfd_putb32 ((bfd_vma
) * buf
, f
);
437 bfd_putl32 ((bfd_vma
) * buf
, f
);
443 memcpy (f
, buf
, byte_len
);
446 /* Create any fixups. */
447 for (i
= 0; i
< num_fixups
; ++i
)
451 /* Don't create fixups for these. That's done during relaxation.
452 We don't need to test for CGEN_INSN_RELAX as they can't get here
455 && CGEN_INSN_ATTR (insn
, CGEN_INSN_RELAXABLE
) != 0
456 && CGEN_OPERAND_ATTR (& CGEN_SYM (operand_table
) [fixups
[i
].opindex
],
457 CGEN_OPERAND_RELAX
) != 0)
460 #ifndef md_cgen_record_fixup_exp
461 #define md_cgen_record_fixup_exp cgen_record_fixup_exp
464 fixP
= md_cgen_record_fixup_exp (frag_now
, f
- frag_now
->fr_literal
,
466 & CGEN_SYM (operand_table
) [fixups
[i
].opindex
],
470 result
->fixups
[i
] = fixP
;
475 result
->num_fixups
= num_fixups
;
480 /* Apply a fixup to the object code. This is called for all the
481 fixups we generated by the call to fix_new_exp, above. In the call
482 above we used a reloc code which was the largest legal reloc code
483 plus the operand index. Here we undo that to recover the operand
484 index. At this point all symbol values should be fully resolved,
485 and we attempt to completely resolve the reloc. If we can not do
486 that, we determine the correct reloc code and put it back in the fixup. */
488 /* FIXME: This function handles some of the fixups and bfd_install_relocation
489 handles the rest. bfd_install_relocation (or some other bfd function)
490 should handle them all. */
493 cgen_md_apply_fix3 (fixP
, valueP
, seg
)
498 char * where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
501 /* FIXME FIXME FIXME: The value we are passed in *valuep includes
502 the symbol values. Since we are using BFD_ASSEMBLER, if we are
503 doing this relocation the code in write.c is going to call
504 bfd_install_relocation, which is also going to use the symbol
505 value. That means that if the reloc is fully resolved we want to
506 use *valuep since bfd_install_relocation is not being used.
507 However, if the reloc is not fully resolved we do not want to use
508 *valuep, and must use fx_offset instead. However, if the reloc
509 is PC relative, we do want to use *valuep since it includes the
510 result of md_pcrel_from. This is confusing. */
512 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
517 else if (fixP
->fx_pcrel
)
521 value
= fixP
->fx_offset
;
522 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
524 if (S_GET_SEGMENT (fixP
->fx_subsy
) == absolute_section
)
525 value
-= S_GET_VALUE (fixP
->fx_subsy
);
528 /* We don't actually support subtracting a symbol. */
529 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
530 _("expression too complex"));
535 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
537 int opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
538 const CGEN_OPERAND
* operand
= & CGEN_SYM (operand_table
) [opindex
];
540 bfd_reloc_code_real_type reloc_type
;
542 const CGEN_INSN
* insn
= (CGEN_INSN
*) fixP
->tc_fix_data
.insn
;
544 /* If the reloc has been fully resolved finish the operand here. */
545 /* FIXME: This duplicates the capabilities of code in BFD. */
547 /* FIXME: If partial_inplace isn't set bfd_install_relocation won't
548 finish the job. Testing for pcrel is a temporary hack. */
551 CGEN_FIELDS_BITSIZE (& fields
) = CGEN_INSN_BITSIZE (insn
);
552 CGEN_SYM (set_operand
) (opindex
, & value
, & fields
);
553 errmsg
= CGEN_SYM (insert_operand
) (opindex
, & fields
, where
);
555 as_warn_where (fixP
->fx_file
, fixP
->fx_line
, "%s\n", errmsg
);
561 /* The operand isn't fully resolved. Determine a BFD reloc value
562 based on the operand information and leave it to
563 bfd_install_relocation. Note that this doesn't work when
564 partial_inplace == false. */
566 reloc_type
= CGEN_SYM (lookup_reloc
) (insn
, operand
, fixP
);
567 if (reloc_type
!= BFD_RELOC_NONE
)
569 fixP
->fx_r_type
= reloc_type
;
573 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
574 _("unresolved expression that must be resolved"));
579 else if (fixP
->fx_done
)
581 /* We're finished with this fixup. Install it because
582 bfd_install_relocation won't be called to do it. */
583 switch (fixP
->fx_r_type
)
586 md_number_to_chars (where
, value
, 1);
589 md_number_to_chars (where
, value
, 2);
592 md_number_to_chars (where
, value
, 4);
594 /* FIXME: later add support for 64 bits. */
601 /* bfd_install_relocation will be called to finish things up. */
604 /* Tuck `value' away for use by tc_gen_reloc.
605 See the comment describing fx_addnumber in write.h.
606 This field is misnamed (or misused :-). */
607 fixP
->fx_addnumber
= value
;
612 /* Translate internal representation of relocation info to BFD target format.
614 FIXME: To what extent can we get all relevant targets to use this? */
617 cgen_tc_gen_reloc (section
, fixP
)
623 reloc
= (arelent
*) bfd_alloc (stdoutput
, sizeof (arelent
));
625 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixP
->fx_r_type
);
626 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
628 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
629 _("internal error: can't export reloc type %d (`%s')"),
630 fixP
->fx_r_type
, bfd_get_reloc_code_name (fixP
->fx_r_type
));
634 assert (!fixP
->fx_pcrel
== !reloc
->howto
->pc_relative
);
636 reloc
->sym_ptr_ptr
= & fixP
->fx_addsy
->bsym
;
637 reloc
->address
= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
638 reloc
->addend
= fixP
->fx_addnumber
;