cgen.c revision 85815
1/* GAS interface for targets using CGEN: Cpu tools GENerator. 2 Copyright 1996, 1997, 1998, 1999, 2000, 2001 3 Free Software Foundation, Inc. 4 5This file is part of GAS, the GNU Assembler. 6 7GAS is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2, or (at your option) 10any later version. 11 12GAS is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GAS; see the file COPYING. If not, write to the Free Software 19Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 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" 31 32/* Opcode table descriptor, must be set by md_begin. */ 33 34CGEN_CPU_DESC gas_cgen_cpu_desc; 35 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. */ 39 40void 41cgen_asm_record_register (name, number) 42 char *name; 43 int number; 44{ 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)); 49} 50 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 ``.''. 54 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 57 being is preferable. 58 59 OPINDEX is the index in the operand table. 60 OPINFO is something the caller chooses to help in reloc determination. */ 61 62struct fixup { 63 int opindex; 64 int opinfo; 65 expressionS exp; 66}; 67 68static struct fixup fixups[GAS_CGEN_MAX_FIXUPS]; 69static int num_fixups; 70 71/* Prepare to parse an instruction. 72 ??? May wish to make this static and delete calls in md_assemble. */ 73 74void 75gas_cgen_init_parse () 76{ 77 num_fixups = 0; 78} 79 80/* Queue a fixup. */ 81 82static void 83queue_fixup (opindex, opinfo, expP) 84 int opindex; 85 int opinfo; 86 expressionS * expP; 87{ 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; 94 ++ num_fixups; 95} 96 97/* The following three functions allow a backup of the fixup chain to be made, 98 and to have this backup be swapped with the current chain. This allows 99 certain ports, eg the m32r, to swap two instructions and swap their fixups 100 at the same time. */ 101/* ??? I think with cgen_asm_finish_insn (or something else) there is no 102 more need for this. */ 103 104static struct fixup saved_fixups[GAS_CGEN_MAX_FIXUPS]; 105static int saved_num_fixups; 106 107void 108gas_cgen_save_fixups () 109{ 110 saved_num_fixups = num_fixups; 111 112 memcpy (saved_fixups, fixups, sizeof (fixups[0]) * num_fixups); 113 114 num_fixups = 0; 115} 116 117void 118gas_cgen_restore_fixups () 119{ 120 num_fixups = saved_num_fixups; 121 122 memcpy (fixups, saved_fixups, sizeof (fixups[0]) * num_fixups); 123 124 saved_num_fixups = 0; 125} 126 127void 128gas_cgen_swap_fixups () 129{ 130 int tmp; 131 struct fixup tmp_fixup; 132 133 if (num_fixups == 0) 134 { 135 gas_cgen_restore_fixups (); 136 } 137 else if (saved_num_fixups == 0) 138 { 139 gas_cgen_save_fixups (); 140 } 141 else 142 { 143 tmp = saved_num_fixups; 144 saved_num_fixups = num_fixups; 145 num_fixups = tmp; 146 147 for (tmp = GAS_CGEN_MAX_FIXUPS; tmp--;) 148 { 149 tmp_fixup = saved_fixups [tmp]; 150 saved_fixups [tmp] = fixups [tmp]; 151 fixups [tmp] = tmp_fixup; 152 } 153 } 154} 155 156/* Default routine to record a fixup. 157 This is a cover function to fix_new. 158 It exists because we record INSN with the fixup. 159 160 FRAG and WHERE are their respective arguments to fix_new_exp. 161 LENGTH is in bits. 162 OPINFO is something the caller chooses to help in reloc determination. 163 164 At this point we do not use a bfd_reloc_code_real_type for 165 operands residing in the insn, but instead just use the 166 operand index. This lets us easily handle fixups for any 167 operand type. We pick a BFD reloc type in md_apply_fix. */ 168 169fixS * 170gas_cgen_record_fixup (frag, where, insn, length, operand, opinfo, symbol, offset) 171 fragS * frag; 172 int where; 173 const CGEN_INSN * insn; 174 int length; 175 const CGEN_OPERAND * operand; 176 int opinfo; 177 symbolS * symbol; 178 offsetT offset; 179{ 180 fixS *fixP; 181 182 /* It may seem strange to use operand->attrs and not insn->attrs here, 183 but it is the operand that has a pc relative relocation. */ 184 185 fixP = fix_new (frag, where, length / 8, symbol, offset, 186 CGEN_OPERAND_ATTR_VALUE (operand, CGEN_OPERAND_PCREL_ADDR), 187 (bfd_reloc_code_real_type) 188 ((int) BFD_RELOC_UNUSED 189 + (int) operand->type)); 190 fixP->fx_cgen.insn = insn; 191 fixP->fx_cgen.opinfo = opinfo; 192 193 return fixP; 194} 195 196/* Default routine to record a fixup given an expression. 197 This is a cover function to fix_new_exp. 198 It exists because we record INSN with the fixup. 199 200 FRAG and WHERE are their respective arguments to fix_new_exp. 201 LENGTH is in bits. 202 OPINFO is something the caller chooses to help in reloc determination. 203 204 At this point we do not use a bfd_reloc_code_real_type for 205 operands residing in the insn, but instead just use the 206 operand index. This lets us easily handle fixups for any 207 operand type. We pick a BFD reloc type in md_apply_fix. */ 208 209fixS * 210gas_cgen_record_fixup_exp (frag, where, insn, length, operand, opinfo, exp) 211 fragS * frag; 212 int where; 213 const CGEN_INSN * insn; 214 int length; 215 const CGEN_OPERAND * operand; 216 int opinfo; 217 expressionS * exp; 218{ 219 fixS *fixP; 220 221 /* It may seem strange to use operand->attrs and not insn->attrs here, 222 but it is the operand that has a pc relative relocation. */ 223 224 fixP = fix_new_exp (frag, where, length / 8, exp, 225 CGEN_OPERAND_ATTR_VALUE (operand, CGEN_OPERAND_PCREL_ADDR), 226 (bfd_reloc_code_real_type) 227 ((int) BFD_RELOC_UNUSED 228 + (int) operand->type)); 229 fixP->fx_cgen.insn = insn; 230 fixP->fx_cgen.opinfo = opinfo; 231 232 return fixP; 233} 234 235/* Used for communication between the next two procedures. */ 236static jmp_buf expr_jmp_buf; 237static int expr_jmp_buf_p; 238 239/* Callback for cgen interface. Parse the expression at *STRP. 240 The result is an error message or NULL for success (in which case 241 *STRP is advanced past the parsed text). 242 WANT is an indication of what the caller is looking for. 243 If WANT == CGEN_ASM_PARSE_INIT the caller is beginning to try to match 244 a table entry with the insn, reset the queued fixups counter. 245 An enum cgen_parse_operand_result is stored in RESULTP. 246 OPINDEX is the operand's table entry index. 247 OPINFO is something the caller chooses to help in reloc determination. 248 The resulting value is stored in VALUEP. */ 249 250const char * 251gas_cgen_parse_operand (cd, want, strP, opindex, opinfo, resultP, valueP) 252 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED; 253 enum cgen_parse_operand_type want; 254 const char **strP; 255 int opindex; 256 int opinfo; 257 enum cgen_parse_operand_result *resultP; 258 bfd_vma *valueP; 259{ 260#ifdef __STDC__ 261 /* These are volatile to survive the setjmp. */ 262 char * volatile hold; 263 enum cgen_parse_operand_result * volatile resultP_1; 264#else 265 static char *hold; 266 static enum cgen_parse_operand_result *resultP_1; 267#endif 268 const char *errmsg = NULL; 269 expressionS exp; 270 271 if (want == CGEN_PARSE_OPERAND_INIT) 272 { 273 gas_cgen_init_parse (); 274 return NULL; 275 } 276 277 resultP_1 = resultP; 278 hold = input_line_pointer; 279 input_line_pointer = (char *) *strP; 280 281 /* We rely on md_operand to longjmp back to us. 282 This is done via gas_cgen_md_operand. */ 283 if (setjmp (expr_jmp_buf) != 0) 284 { 285 expr_jmp_buf_p = 0; 286 input_line_pointer = (char *) hold; 287 *resultP_1 = CGEN_PARSE_OPERAND_RESULT_ERROR; 288 return "illegal operand"; 289 } 290 291 expr_jmp_buf_p = 1; 292 expression (&exp); 293 expr_jmp_buf_p = 0; 294 295 *strP = input_line_pointer; 296 input_line_pointer = hold; 297 298 /* FIXME: Need to check `want'. */ 299 300 switch (exp.X_op) 301 { 302 case O_illegal: 303 errmsg = _("illegal operand"); 304 *resultP = CGEN_PARSE_OPERAND_RESULT_ERROR; 305 break; 306 case O_absent: 307 errmsg = _("missing operand"); 308 *resultP = CGEN_PARSE_OPERAND_RESULT_ERROR; 309 break; 310 case O_constant: 311 *valueP = exp.X_add_number; 312 *resultP = CGEN_PARSE_OPERAND_RESULT_NUMBER; 313 break; 314 case O_register: 315 *valueP = exp.X_add_number; 316 *resultP = CGEN_PARSE_OPERAND_RESULT_REGISTER; 317 break; 318 default: 319 queue_fixup (opindex, opinfo, &exp); 320 *valueP = 0; 321 *resultP = CGEN_PARSE_OPERAND_RESULT_QUEUED; 322 break; 323 } 324 325 return errmsg; 326} 327 328/* md_operand handler to catch unrecognized expressions and halt the 329 parsing process so the next entry can be tried. 330 331 ??? This could be done differently by adding code to `expression'. */ 332 333void 334gas_cgen_md_operand (expressionP) 335 expressionS *expressionP ATTRIBUTE_UNUSED; 336{ 337 /* Don't longjmp if we're not called from within cgen_parse_operand(). */ 338 if (expr_jmp_buf_p) 339 longjmp (expr_jmp_buf, 1); 340} 341 342/* Finish assembling instruction INSN. 343 BUF contains what we've built up so far. 344 LENGTH is the size of the insn in bits. 345 RELAX_P is non-zero if relaxable insns should be emitted as such. 346 Otherwise they're emitted in non-relaxable forms. 347 The "result" is stored in RESULT if non-NULL. */ 348 349void 350gas_cgen_finish_insn (insn, buf, length, relax_p, result) 351 const CGEN_INSN *insn; 352 CGEN_INSN_BYTES_PTR buf; 353 unsigned int length; 354 int relax_p; 355 finished_insnS *result; 356{ 357 int i; 358 int relax_operand; 359 char *f; 360 unsigned int byte_len = length / 8; 361 362 /* ??? Target foo issues various warnings here, so one might want to provide 363 a hook here. However, our caller is defined in tc-foo.c so there 364 shouldn't be a need for a hook. */ 365 366 /* Write out the instruction. 367 It is important to fetch enough space in one call to `frag_more'. 368 We use (f - frag_now->fr_literal) to compute where we are and we 369 don't want frag_now to change between calls. 370 371 Relaxable instructions: We need to ensure we allocate enough 372 space for the largest insn. */ 373 374 if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAX)) 375 /* These currently shouldn't get here. */ 376 abort (); 377 378 /* Is there a relaxable insn with the relaxable operand needing a fixup? */ 379 380 relax_operand = -1; 381 if (relax_p && CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXABLE)) 382 { 383 /* Scan the fixups for the operand affected by relaxing 384 (i.e. the branch address). */ 385 386 for (i = 0; i < num_fixups; ++i) 387 { 388 if (CGEN_OPERAND_ATTR_VALUE (cgen_operand_lookup_by_num (gas_cgen_cpu_desc, fixups[i].opindex), 389 CGEN_OPERAND_RELAX)) 390 { 391 relax_operand = i; 392 break; 393 } 394 } 395 } 396 397 if (relax_operand != -1) 398 { 399 int max_len; 400 fragS *old_frag; 401 expressionS *exp; 402 symbolS *sym; 403 offsetT off; 404 405#ifdef TC_CGEN_MAX_RELAX 406 max_len = TC_CGEN_MAX_RELAX (insn, byte_len); 407#else 408 max_len = CGEN_MAX_INSN_SIZE; 409#endif 410 /* Ensure variable part and fixed part are in same fragment. */ 411 /* FIXME: Having to do this seems like a hack. */ 412 frag_grow (max_len); 413 414 /* Allocate space for the fixed part. */ 415 f = frag_more (byte_len); 416 417 /* Create a relaxable fragment for this instruction. */ 418 old_frag = frag_now; 419 420 exp = &fixups[relax_operand].exp; 421 sym = exp->X_add_symbol; 422 off = exp->X_add_number; 423 if (exp->X_op != O_constant && exp->X_op != O_symbol) 424 { 425 /* Handle complex expressions. */ 426 sym = make_expr_symbol (exp); 427 off = 0; 428 } 429 430 frag_var (rs_machine_dependent, 431 max_len - byte_len /* max chars */, 432 0 /* variable part already allocated */, 433 /* FIXME: When we machine generate the relax table, 434 machine generate a macro to compute subtype. */ 435 1 /* subtype */, 436 sym, 437 off, 438 f); 439 440 /* Record the operand number with the fragment so md_convert_frag 441 can use gas_cgen_md_record_fixup to record the appropriate reloc. */ 442 old_frag->fr_cgen.insn = insn; 443 old_frag->fr_cgen.opindex = fixups[relax_operand].opindex; 444 old_frag->fr_cgen.opinfo = fixups[relax_operand].opinfo; 445 if (result) 446 result->frag = old_frag; 447 } 448 else 449 { 450 f = frag_more (byte_len); 451 if (result) 452 result->frag = frag_now; 453 } 454 455 /* If we're recording insns as numbers (rather than a string of bytes), 456 target byte order handling is deferred until now. */ 457#if CGEN_INT_INSN_P 458 cgen_put_insn_value (gas_cgen_cpu_desc, f, length, *buf); 459#else 460 memcpy (f, buf, byte_len); 461#endif 462 463 /* Emit DWARF2 debugging information. */ 464 dwarf2_emit_insn (byte_len); 465 466 /* Create any fixups. */ 467 for (i = 0; i < num_fixups; ++i) 468 { 469 fixS *fixP; 470 const CGEN_OPERAND *operand = 471 cgen_operand_lookup_by_num (gas_cgen_cpu_desc, fixups[i].opindex); 472 473 /* Don't create fixups for these. That's done during relaxation. 474 We don't need to test for CGEN_INSN_RELAX as they can't get here 475 (see above). */ 476 if (relax_p 477 && CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXABLE) 478 && CGEN_OPERAND_ATTR_VALUE (operand, CGEN_OPERAND_RELAX)) 479 continue; 480 481#ifndef md_cgen_record_fixup_exp 482#define md_cgen_record_fixup_exp gas_cgen_record_fixup_exp 483#endif 484 485 fixP = md_cgen_record_fixup_exp (frag_now, f - frag_now->fr_literal, 486 insn, length, operand, 487 fixups[i].opinfo, 488 &fixups[i].exp); 489 if (result) 490 result->fixups[i] = fixP; 491 } 492 493 if (result) 494 { 495 result->num_fixups = num_fixups; 496 result->addr = f; 497 } 498} 499 500/* Apply a fixup to the object code. This is called for all the 501 fixups we generated by the call to fix_new_exp, above. In the call 502 above we used a reloc code which was the largest legal reloc code 503 plus the operand index. Here we undo that to recover the operand 504 index. At this point all symbol values should be fully resolved, 505 and we attempt to completely resolve the reloc. If we can not do 506 that, we determine the correct reloc code and put it back in the fixup. */ 507 508/* FIXME: This function handles some of the fixups and bfd_install_relocation 509 handles the rest. bfd_install_relocation (or some other bfd function) 510 should handle them all. */ 511 512int 513gas_cgen_md_apply_fix3 (fixP, valueP, seg) 514 fixS * fixP; 515 valueT * valueP; 516 segT seg ATTRIBUTE_UNUSED; 517{ 518 char *where = fixP->fx_frag->fr_literal + fixP->fx_where; 519 valueT value; 520 /* Canonical name, since used a lot. */ 521 CGEN_CPU_DESC cd = gas_cgen_cpu_desc; 522 523 /* FIXME FIXME FIXME: The value we are passed in *valuep includes 524 the symbol values. Since we are using BFD_ASSEMBLER, if we are 525 doing this relocation the code in write.c is going to call 526 bfd_install_relocation, which is also going to use the symbol 527 value. That means that if the reloc is fully resolved we want to 528 use *valuep since bfd_install_relocation is not being used. 529 However, if the reloc is not fully resolved we do not want to use 530 *valuep, and must use fx_offset instead. However, if the reloc 531 is PC relative, we do want to use *valuep since it includes the 532 result of md_pcrel_from. This is confusing. */ 533 534 if (fixP->fx_addsy == (symbolS *) NULL) 535 { 536 value = *valueP; 537 fixP->fx_done = 1; 538 } 539 else if (fixP->fx_pcrel) 540 value = *valueP; 541 else 542 { 543 value = fixP->fx_offset; 544 if (fixP->fx_subsy != (symbolS *) NULL) 545 { 546 if (S_GET_SEGMENT (fixP->fx_subsy) == absolute_section) 547 value -= S_GET_VALUE (fixP->fx_subsy); 548 else 549 { 550 /* We don't actually support subtracting a symbol. */ 551 as_bad_where (fixP->fx_file, fixP->fx_line, 552 _("expression too complex")); 553 } 554 } 555 } 556 557 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED) 558 { 559 int opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED; 560 const CGEN_OPERAND *operand = cgen_operand_lookup_by_num (cd, opindex); 561 const char *errmsg; 562 bfd_reloc_code_real_type reloc_type; 563 CGEN_FIELDS *fields = alloca (CGEN_CPU_SIZEOF_FIELDS (cd)); 564 const CGEN_INSN *insn = fixP->fx_cgen.insn; 565 566 /* If the reloc has been fully resolved finish the operand here. */ 567 /* FIXME: This duplicates the capabilities of code in BFD. */ 568 if (fixP->fx_done 569 /* FIXME: If partial_inplace isn't set bfd_install_relocation won't 570 finish the job. Testing for pcrel is a temporary hack. */ 571 || fixP->fx_pcrel) 572 { 573 CGEN_CPU_SET_FIELDS_BITSIZE (cd) (fields, CGEN_INSN_BITSIZE (insn)); 574 CGEN_CPU_SET_VMA_OPERAND (cd) (cd, opindex, fields, (bfd_vma) value); 575 576#if CGEN_INT_INSN_P 577 { 578 CGEN_INSN_INT insn_value = 579 cgen_get_insn_value (cd, where, CGEN_INSN_BITSIZE (insn)); 580 581 /* ??? 0 is passed for `pc'. */ 582 errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields, 583 &insn_value, (bfd_vma) 0); 584 cgen_put_insn_value (cd, where, CGEN_INSN_BITSIZE (insn), 585 insn_value); 586 } 587#else 588 /* ??? 0 is passed for `pc'. */ 589 errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields, where, 590 (bfd_vma) 0); 591#endif 592 if (errmsg) 593 as_bad_where (fixP->fx_file, fixP->fx_line, "%s", errmsg); 594 } 595 596 if (fixP->fx_done) 597 return 1; 598 599 /* The operand isn't fully resolved. Determine a BFD reloc value 600 based on the operand information and leave it to 601 bfd_install_relocation. Note that this doesn't work when 602 partial_inplace == false. */ 603 604 reloc_type = md_cgen_lookup_reloc (insn, operand, fixP); 605 if (reloc_type != BFD_RELOC_NONE) 606 { 607 fixP->fx_r_type = reloc_type; 608 } 609 else 610 { 611 as_bad_where (fixP->fx_file, fixP->fx_line, 612 _("unresolved expression that must be resolved")); 613 fixP->fx_done = 1; 614 return 1; 615 } 616 } 617 else if (fixP->fx_done) 618 { 619 /* We're finished with this fixup. Install it because 620 bfd_install_relocation won't be called to do it. */ 621 switch (fixP->fx_r_type) 622 { 623 case BFD_RELOC_8: 624 md_number_to_chars (where, value, 1); 625 break; 626 case BFD_RELOC_16: 627 md_number_to_chars (where, value, 2); 628 break; 629 case BFD_RELOC_32: 630 md_number_to_chars (where, value, 4); 631 break; 632 case BFD_RELOC_64: 633 md_number_to_chars (where, value, 8); 634 break; 635 default: 636 as_bad_where (fixP->fx_file, fixP->fx_line, 637 _("internal error: can't install fix for reloc type %d (`%s')"), 638 fixP->fx_r_type, bfd_get_reloc_code_name (fixP->fx_r_type)); 639 break; 640 } 641 } 642 else 643 { 644 /* bfd_install_relocation will be called to finish things up. */ 645 } 646 647 /* Tuck `value' away for use by tc_gen_reloc. 648 See the comment describing fx_addnumber in write.h. 649 This field is misnamed (or misused :-). */ 650 fixP->fx_addnumber = value; 651 652 return 1; 653} 654 655/* Translate internal representation of relocation info to BFD target format. 656 657 FIXME: To what extent can we get all relevant targets to use this? */ 658 659arelent * 660gas_cgen_tc_gen_reloc (section, fixP) 661 asection * section ATTRIBUTE_UNUSED; 662 fixS * fixP; 663{ 664 arelent *reloc; 665 666 reloc = (arelent *) xmalloc (sizeof (arelent)); 667 668 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type); 669 if (reloc->howto == (reloc_howto_type *) NULL) 670 { 671 as_bad_where (fixP->fx_file, fixP->fx_line, 672 _("relocation is not supported")); 673 return NULL; 674 } 675 676 assert (!fixP->fx_pcrel == !reloc->howto->pc_relative); 677 678 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); 679 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy); 680 681 /* Use fx_offset for these cases. */ 682 if (fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY 683 || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT) 684 reloc->addend = fixP->fx_offset; 685 else 686 reloc->addend = fixP->fx_addnumber; 687 688 reloc->address = fixP->fx_frag->fr_address + fixP->fx_where; 689 return reloc; 690} 691