1 /* tc-iq2000.c -- Assembler for the Sitera IQ2000. 2 Copyright (C) 2003, 2004, 2005, 2006, 2007 3 Free Software Foundation. Inc. 4 5 This file is part of GAS, the GNU Assembler. 6 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 3, or (at your option) 10 any later version. 11 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. 16 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 19 the Free Software Foundation, 51 Franklin Street - Fifth Floor, 20 Boston, MA 02110-1301, USA. */ 21 22 #include "as.h" 23 #include "safe-ctype.h" 24 #include "subsegs.h" 25 #include "symcat.h" 26 #include "opcodes/iq2000-desc.h" 27 #include "opcodes/iq2000-opc.h" 28 #include "cgen.h" 29 #include "elf/common.h" 30 #include "elf/iq2000.h" 31 #include "libbfd.h" 32 #include "sb.h" 33 #include "macro.h" 34 35 /* Structure to hold all of the different components describing 36 an individual instruction. */ 37 typedef struct 38 { 39 const CGEN_INSN * insn; 40 const CGEN_INSN * orig_insn; 41 CGEN_FIELDS fields; 42 #if CGEN_INT_INSN_P 43 CGEN_INSN_INT buffer [1]; 44 #define INSN_VALUE(buf) (*(buf)) 45 #else 46 unsigned char buffer [CGEN_MAX_INSN_SIZE]; 47 #define INSN_VALUE(buf) (buf) 48 #endif 49 char * addr; 50 fragS * frag; 51 int num_fixups; 52 fixS * fixups [GAS_CGEN_MAX_FIXUPS]; 53 int indices [MAX_OPERAND_INSTANCES]; 54 } 55 iq2000_insn; 56 57 const char comment_chars[] = "#"; 58 const char line_comment_chars[] = "#"; 59 const char line_separator_chars[] = ";"; 60 const char EXP_CHARS[] = "eE"; 61 const char FLT_CHARS[] = "dD"; 62 63 /* Default machine. */ 64 #define DEFAULT_MACHINE bfd_mach_iq2000 65 #define DEFAULT_FLAGS EF_IQ2000_CPU_IQ2000 66 67 static unsigned long iq2000_mach = bfd_mach_iq2000; 68 static int cpu_mach = (1 << MACH_IQ2000); 69 70 /* Flags to set in the elf header. */ 71 static flagword iq2000_flags = DEFAULT_FLAGS; 72 73 typedef struct proc 74 { 75 symbolS *isym; 76 unsigned long reg_mask; 77 unsigned long reg_offset; 78 unsigned long fpreg_mask; 79 unsigned long fpreg_offset; 80 unsigned long frame_offset; 81 unsigned long frame_reg; 82 unsigned long pc_reg; 83 } procS; 84 85 static procS cur_proc; 86 static procS *cur_proc_ptr; 87 static int numprocs; 88 89 /* Relocations against symbols are done in two 90 parts, with a HI relocation and a LO relocation. Each relocation 91 has only 16 bits of space to store an addend. This means that in 92 order for the linker to handle carries correctly, it must be able 93 to locate both the HI and the LO relocation. This means that the 94 relocations must appear in order in the relocation table. 95 96 In order to implement this, we keep track of each unmatched HI 97 relocation. We then sort them so that they immediately precede the 98 corresponding LO relocation. */ 99 100 struct iq2000_hi_fixup 101 { 102 struct iq2000_hi_fixup * next; /* Next HI fixup. */ 103 fixS * fixp; /* This fixup. */ 104 segT seg; /* The section this fixup is in. */ 105 }; 106 107 /* The list of unmatched HI relocs. */ 108 static struct iq2000_hi_fixup * iq2000_hi_fixup_list; 109 110 /* Macro hash table, which we will add to. */ 111 extern struct hash_control *macro_hash; 112 113 const char *md_shortopts = ""; 114 struct option md_longopts[] = 115 { 116 {NULL, no_argument, NULL, 0} 117 }; 118 size_t md_longopts_size = sizeof (md_longopts); 119 120 int 121 md_parse_option (int c ATTRIBUTE_UNUSED, 122 char * arg ATTRIBUTE_UNUSED) 123 { 124 return 0; 125 } 126 127 void 128 md_show_usage (FILE * stream ATTRIBUTE_UNUSED) 129 { 130 } 131 132 /* Automatically enter conditional branch macros. */ 133 134 typedef struct 135 { 136 const char * mnemonic; 137 const char ** expansion; 138 const char ** args; 139 } iq2000_macro_defs_s; 140 141 static const char * abs_args[] = { "rd", "rs", "scratch=%1", NULL }; 142 static const char * abs_expn = "\n sra \\rd,\\rs,31\n xor \\scratch,\\rd,\\rs\n sub \\rd,\\scratch,\\rd\n"; 143 static const char * la_expn = "\n lui \\reg,%hi(\\label)\n ori \\reg,\\reg,%lo(\\label)\n"; 144 static const char * la_args[] = { "reg", "label", NULL }; 145 static const char * bxx_args[] = { "rs", "rt", "label", "scratch=%1", NULL }; 146 static const char * bge_expn = "\n slt \\scratch,\\rs,\\rt\n beq %0,\\scratch,\\label\n"; 147 static const char * bgeu_expn = "\n sltu \\scratch,\\rs,\\rt\n beq %0,\\scratch,\\label\n"; 148 static const char * bgt_expn = "\n slt \\scratch,\\rt,\\rs\n bne %0,\\scratch,\\label\n"; 149 static const char * bgtu_expn = "\n sltu \\scratch,\\rt,\\rs\n bne %0,\\scratch,\\label\n"; 150 static const char * ble_expn = "\n slt \\scratch,\\rt,\\rs\n beq %0,\\scratch,\\label\n"; 151 static const char * bleu_expn = "\n sltu \\scratch,\\rt,\\rs\n beq %0,\\scratch,\\label\n"; 152 static const char * blt_expn = "\n slt \\scratch,\\rs,\\rt\n bne %0,\\scratch,\\label\n"; 153 static const char * bltu_expn = "\n sltu \\scratch,\\rs,\\rt\n bne %0,\\scratch,\\label\n"; 154 static const char * sxx_args[] = { "rd", "rs", "rt", NULL }; 155 static const char * sge_expn = "\n slt \\rd,\\rs,\\rt\n xori \\rd,\\rd,1\n"; 156 static const char * sgeu_expn = "\n sltu \\rd,\\rs,\\rt\n xori \\rd,\\rd,1\n"; 157 static const char * sle_expn = "\n slt \\rd,\\rt,\\rs\n xori \\rd,\\rd,1\n"; 158 static const char * sleu_expn = "\n sltu \\rd,\\rt,\\rs\n xori \\rd,\\rd,1\n"; 159 static const char * sgt_expn = "\n slt \\rd,\\rt,\\rs\n"; 160 static const char * sgtu_expn = "\n sltu \\rd,\\rt,\\rs\n"; 161 static const char * sne_expn = "\n xor \\rd,\\rt,\\rs\n sltu \\rd,%0,\\rd\n"; 162 static const char * seq_expn = "\n xor \\rd,\\rt,\\rs\n sltu \\rd,%0,\\rd\n xori \\rd,\\rd,1\n"; 163 static const char * ai32_args[] = { "rt", "rs", "imm", NULL }; 164 static const char * andi32_expn = "\n\ 165 .if (\\imm & 0xffff0000 == 0xffff0000)\n\ 166 andoi \\rt,\\rs,%lo(\\imm)\n\ 167 .elseif (\\imm & 0x0000ffff == 0x0000ffff)\n\ 168 andoui \\rt,\\rs,%uhi(\\imm)\n\ 169 .elseif (\\imm & 0xffff0000 == 0x00000000)\n\ 170 andi \\rt,\\rs,%lo(\\imm)\n\ 171 .else\n\ 172 andoui \\rt,\\rs,%uhi(\\imm)\n\ 173 andoi \\rt,\\rt,%lo(\\imm)\n\ 174 .endif\n"; 175 static const char * ori32_expn = "\n\ 176 .if (\\imm & 0xffff == 0)\n\ 177 orui \\rt,\\rs,%uhi(\\imm)\n\ 178 .elseif (\\imm & 0xffff0000 == 0)\n\ 179 ori \\rt,\\rs,%lo(\\imm)\n\ 180 .else\n\ 181 orui \\rt,\\rs,%uhi(\\imm)\n\ 182 ori \\rt,\\rt,%lo(\\imm)\n\ 183 .endif\n"; 184 185 static const char * neg_args[] = { "rd", "rs", NULL }; 186 static const char * neg_expn = "\n sub \\rd,%0,\\rs\n"; 187 static const char * negu_expn = "\n subu \\rd,%0,\\rs\n"; 188 static const char * li_args[] = { "rt", "imm", NULL }; 189 static const char * li_expn = "\n\ 190 .if (\\imm & 0xffff0000 == 0x0)\n\ 191 ori \\rt,%0,\\imm\n\ 192 .elseif (\\imm & 0xffff0000 == 0xffff0000)\n\ 193 addi \\rt,%0,\\imm\n\ 194 .elseif (\\imm & 0x0000ffff == 0)\n\ 195 lui \\rt,%uhi(\\imm)\n\ 196 .else\n\ 197 lui \\rt,%uhi(\\imm)\n\ 198 ori \\rt,\\rt,%lo(\\imm)\n\ 199 .endif\n"; 200 201 static iq2000_macro_defs_s iq2000_macro_defs[] = 202 { 203 {"abs", (const char **) & abs_expn, (const char **) & abs_args}, 204 {"la", (const char **) & la_expn, (const char **) & la_args}, 205 {"bge", (const char **) & bge_expn, (const char **) & bxx_args}, 206 {"bgeu", (const char **) & bgeu_expn, (const char **) & bxx_args}, 207 {"bgt", (const char **) & bgt_expn, (const char **) & bxx_args}, 208 {"bgtu", (const char **) & bgtu_expn, (const char **) & bxx_args}, 209 {"ble", (const char **) & ble_expn, (const char **) & bxx_args}, 210 {"bleu", (const char **) & bleu_expn, (const char **) & bxx_args}, 211 {"blt", (const char **) & blt_expn, (const char **) & bxx_args}, 212 {"bltu", (const char **) & bltu_expn, (const char **) & bxx_args}, 213 {"sge", (const char **) & sge_expn, (const char **) & sxx_args}, 214 {"sgeu", (const char **) & sgeu_expn, (const char **) & sxx_args}, 215 {"sle", (const char **) & sle_expn, (const char **) & sxx_args}, 216 {"sleu", (const char **) & sleu_expn, (const char **) & sxx_args}, 217 {"sgt", (const char **) & sgt_expn, (const char **) & sxx_args}, 218 {"sgtu", (const char **) & sgtu_expn, (const char **) & sxx_args}, 219 {"seq", (const char **) & seq_expn, (const char **) & sxx_args}, 220 {"sne", (const char **) & sne_expn, (const char **) & sxx_args}, 221 {"neg", (const char **) & neg_expn, (const char **) & neg_args}, 222 {"negu", (const char **) & negu_expn, (const char **) & neg_args}, 223 {"li", (const char **) & li_expn, (const char **) & li_args}, 224 {"ori32", (const char **) & ori32_expn, (const char **) & ai32_args}, 225 {"andi32",(const char **) & andi32_expn,(const char **) & ai32_args}, 226 }; 227 228 static void 229 iq2000_add_macro (const char * name, 230 const char * semantics, 231 const char ** arguments) 232 { 233 macro_entry *macro; 234 sb macro_name; 235 const char *namestr; 236 237 macro = xmalloc (sizeof (macro_entry)); 238 sb_new (& macro->sub); 239 sb_new (& macro_name); 240 241 macro->formal_count = 0; 242 macro->formals = 0; 243 244 sb_add_string (& macro->sub, semantics); 245 246 if (arguments != NULL) 247 { 248 formal_entry ** p = ¯o->formals; 249 250 macro->formal_count = 0; 251 macro->formal_hash = hash_new (); 252 253 while (*arguments != NULL) 254 { 255 formal_entry *formal; 256 257 formal = xmalloc (sizeof (formal_entry)); 258 259 sb_new (& formal->name); 260 sb_new (& formal->def); 261 sb_new (& formal->actual); 262 263 /* chlm: Added the following to allow defaulted args. */ 264 if (strchr (*arguments,'=')) 265 { 266 char * tt_args = strdup (*arguments); 267 char * tt_dflt = strchr (tt_args,'='); 268 269 *tt_dflt = 0; 270 sb_add_string (& formal->name, tt_args); 271 sb_add_string (& formal->def, tt_dflt + 1); 272 } 273 else 274 sb_add_string (& formal->name, *arguments); 275 276 /* Add to macro's hash table. */ 277 hash_jam (macro->formal_hash, sb_terminate (& formal->name), formal); 278 279 formal->index = macro->formal_count; 280 macro->formal_count++; 281 *p = formal; 282 p = & formal->next; 283 *p = NULL; 284 ++arguments; 285 } 286 } 287 288 sb_add_string (¯o_name, name); 289 namestr = sb_terminate (¯o_name); 290 hash_jam (macro_hash, namestr, macro); 291 292 macro_defined = 1; 293 } 294 295 static void 296 iq2000_load_macros (void) 297 { 298 int i; 299 int mcnt = ARRAY_SIZE (iq2000_macro_defs); 300 301 for (i = 0; i < mcnt; i++) 302 iq2000_add_macro (iq2000_macro_defs[i].mnemonic, 303 *iq2000_macro_defs[i].expansion, 304 iq2000_macro_defs[i].args); 305 } 306 307 void 308 md_begin (void) 309 { 310 /* Initialize the `cgen' interface. */ 311 312 /* Set the machine number and endian. */ 313 gas_cgen_cpu_desc = iq2000_cgen_cpu_open (CGEN_CPU_OPEN_MACHS, cpu_mach, 314 CGEN_CPU_OPEN_ENDIAN, 315 CGEN_ENDIAN_BIG, 316 CGEN_CPU_OPEN_END); 317 iq2000_cgen_init_asm (gas_cgen_cpu_desc); 318 319 /* This is a callback from cgen to gas to parse operands. */ 320 cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand); 321 322 /* Set the ELF flags if desired. */ 323 if (iq2000_flags) 324 bfd_set_private_flags (stdoutput, iq2000_flags); 325 326 /* Set the machine type */ 327 bfd_default_set_arch_mach (stdoutput, bfd_arch_iq2000, iq2000_mach); 328 329 iq2000_load_macros (); 330 } 331 332 void 333 md_assemble (char * str) 334 { 335 static long delayed_load_register = 0; 336 static int last_insn_had_delay_slot = 0; 337 static int last_insn_has_load_delay = 0; 338 static int last_insn_unconditional_jump = 0; 339 static int last_insn_was_ldw = 0; 340 341 iq2000_insn insn; 342 char * errmsg; 343 344 /* Initialize GAS's cgen interface for a new instruction. */ 345 gas_cgen_init_parse (); 346 347 insn.insn = iq2000_cgen_assemble_insn 348 (gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg); 349 350 if (!insn.insn) 351 { 352 as_bad ("%s", errmsg); 353 return; 354 } 355 356 /* Doesn't really matter what we pass for RELAX_P here. */ 357 gas_cgen_finish_insn (insn.insn, insn.buffer, 358 CGEN_FIELDS_BITSIZE (& insn.fields), 1, NULL); 359 360 /* We need to generate an error if there's a yielding instruction in the delay 361 slot of a control flow modifying instruction (jump (yes), load (no)) */ 362 if ((last_insn_had_delay_slot && !last_insn_has_load_delay) && 363 CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_YIELD_INSN)) 364 as_bad (_("the yielding instruction %s may not be in a delay slot."), 365 CGEN_INSN_NAME (insn.insn)); 366 367 /* Warn about odd numbered base registers for paired-register 368 instructions like LDW. On iq2000, result is always rt. */ 369 if (iq2000_mach == bfd_mach_iq2000 370 && CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_EVEN_REG_NUM) 371 && (insn.fields.f_rt % 2)) 372 as_bad (_("Register number (R%ld) for double word access must be even."), 373 insn.fields.f_rt); 374 375 /* Warn about insns that reference the target of a previous load. */ 376 /* NOTE: R0 is a special case and is not subject to load delays (except for ldw). */ 377 if (delayed_load_register && (last_insn_has_load_delay || last_insn_was_ldw)) 378 { 379 if (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_USES_RD) && 380 insn.fields.f_rd == delayed_load_register) 381 as_warn (_("operand references R%ld of previous load."), 382 insn.fields.f_rd); 383 384 if (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_USES_RS) && 385 insn.fields.f_rs == delayed_load_register) 386 as_warn (_("operand references R%ld of previous load."), 387 insn.fields.f_rs); 388 389 if (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_USES_RT) && 390 insn.fields.f_rt == delayed_load_register) 391 as_warn (_("operand references R%ld of previous load."), 392 insn.fields.f_rt); 393 394 if (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_USES_R31) && 395 delayed_load_register == 31) 396 as_warn (_("instruction implicitly accesses R31 of previous load.")); 397 } 398 399 /* Warn about insns that reference the (target + 1) of a previous ldw. */ 400 if (last_insn_was_ldw) 401 { 402 if ((CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_USES_RD) 403 && insn.fields.f_rd == delayed_load_register + 1) 404 || (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_USES_RS) 405 && insn.fields.f_rs == delayed_load_register + 1) 406 || (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_USES_RT) 407 && insn.fields.f_rt == delayed_load_register + 1)) 408 as_warn (_("operand references R%ld of previous load."), 409 delayed_load_register + 1); 410 } 411 412 last_insn_had_delay_slot = 413 CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_DELAY_SLOT); 414 415 last_insn_has_load_delay = 416 CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_LOAD_DELAY); 417 418 if (last_insn_unconditional_jump) 419 last_insn_has_load_delay = last_insn_unconditional_jump = 0; 420 else if (! strcmp (CGEN_INSN_MNEMONIC (insn.insn), "j") 421 || ! strcmp (CGEN_INSN_MNEMONIC (insn.insn), "jal")) 422 last_insn_unconditional_jump = 1; 423 424 /* The meaning of EVEN_REG_NUM was overloaded to also imply LDW. Since 425 that's not true for IQ10, let's make the above logic specific to LDW. */ 426 last_insn_was_ldw = ! strcmp ("ldw", CGEN_INSN_NAME (insn.insn)); 427 428 /* The assumption here is that the target of a load is always rt. */ 429 delayed_load_register = insn.fields.f_rt; 430 } 431 432 valueT 433 md_section_align (segT segment, valueT size) 434 { 435 int align = bfd_get_section_alignment (stdoutput, segment); 436 return ((size + (1 << align) - 1) & (-1 << align)); 437 } 438 439 symbolS * 440 md_undefined_symbol (char * name ATTRIBUTE_UNUSED) 441 { 442 return 0; 443 } 444 445 /* Interface to relax_segment. */ 446 447 /* Return an initial guess of the length by which a fragment must grow to 448 hold a branch to reach its destination. 449 Also updates fr_type/fr_subtype as necessary. 450 451 Called just before doing relaxation. 452 Any symbol that is now undefined will not become defined. 453 The guess for fr_var is ACTUALLY the growth beyond fr_fix. 454 Whatever we do to grow fr_fix or fr_var contributes to our returned value. 455 Although it may not be explicit in the frag, pretend fr_var starts with a 456 0 value. */ 457 458 int 459 md_estimate_size_before_relax (fragS * fragP, 460 segT segment ATTRIBUTE_UNUSED) 461 { 462 int old_fr_fix = fragP->fr_fix; 463 464 /* The only thing we have to handle here are symbols outside of the 465 current segment. They may be undefined or in a different segment in 466 which case linker scripts may place them anywhere. 467 However, we can't finish the fragment here and emit the reloc as insn 468 alignment requirements may move the insn about. */ 469 470 return (fragP->fr_var + fragP->fr_fix - old_fr_fix); 471 } 472 473 /* *fragP has been relaxed to its final size, and now needs to have 474 the bytes inside it modified to conform to the new size. 475 476 Called after relaxation is finished. 477 fragP->fr_type == rs_machine_dependent. 478 fragP->fr_subtype is the subtype of what the address relaxed to. */ 479 480 void 481 md_convert_frag (bfd * abfd ATTRIBUTE_UNUSED, 482 segT sec ATTRIBUTE_UNUSED, 483 fragS * fragP ATTRIBUTE_UNUSED) 484 { 485 } 486 487 488 /* Functions concerning relocs. */ 489 490 long 491 md_pcrel_from_section (fixS * fixP, segT sec) 492 { 493 if (fixP->fx_addsy != (symbolS *) NULL 494 && (! S_IS_DEFINED (fixP->fx_addsy) 495 || S_GET_SEGMENT (fixP->fx_addsy) != sec)) 496 { 497 /* The symbol is undefined (or is defined but not in this section). 498 Let the linker figure it out. */ 499 return 0; 500 } 501 502 /* Return the address of the delay slot. */ 503 return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address; 504 } 505 506 /* Return the bfd reloc type for OPERAND of INSN at fixup FIXP. 507 Returns BFD_RELOC_NONE if no reloc type can be found. 508 *FIXP may be modified if desired. */ 509 510 bfd_reloc_code_real_type 511 md_cgen_lookup_reloc (const CGEN_INSN * insn ATTRIBUTE_UNUSED, 512 const CGEN_OPERAND * operand, 513 fixS * fixP ATTRIBUTE_UNUSED) 514 { 515 switch (operand->type) 516 { 517 case IQ2000_OPERAND_OFFSET: return BFD_RELOC_16_PCREL_S2; 518 case IQ2000_OPERAND_JMPTARG: return BFD_RELOC_IQ2000_OFFSET_16; 519 case IQ2000_OPERAND_JMPTARGQ10: return BFD_RELOC_NONE; 520 case IQ2000_OPERAND_HI16: return BFD_RELOC_HI16; 521 case IQ2000_OPERAND_LO16: return BFD_RELOC_LO16; 522 default: break; 523 } 524 525 return BFD_RELOC_NONE; 526 } 527 528 /* Record a HI16 reloc for later matching with its LO16 cousin. */ 529 530 static void 531 iq2000_record_hi16 (int reloc_type, 532 fixS * fixP, 533 segT seg ATTRIBUTE_UNUSED) 534 { 535 struct iq2000_hi_fixup * hi_fixup; 536 537 assert (reloc_type == BFD_RELOC_HI16); 538 539 hi_fixup = xmalloc (sizeof * hi_fixup); 540 hi_fixup->fixp = fixP; 541 hi_fixup->seg = now_seg; 542 hi_fixup->next = iq2000_hi_fixup_list; 543 544 iq2000_hi_fixup_list = hi_fixup; 545 } 546 547 /* Called while parsing an instruction to create a fixup. 548 We need to check for HI16 relocs and queue them up for later sorting. */ 549 550 fixS * 551 iq2000_cgen_record_fixup_exp (fragS * frag, 552 int where, 553 const CGEN_INSN * insn, 554 int length, 555 const CGEN_OPERAND * operand, 556 int opinfo, 557 expressionS * exp) 558 { 559 fixS * fixP = gas_cgen_record_fixup_exp (frag, where, insn, length, 560 operand, opinfo, exp); 561 562 if (operand->type == IQ2000_OPERAND_HI16 563 /* If low/high was used, it is recorded in `opinfo'. */ 564 && (fixP->fx_cgen.opinfo == BFD_RELOC_HI16 565 || fixP->fx_cgen.opinfo == BFD_RELOC_LO16)) 566 iq2000_record_hi16 (fixP->fx_cgen.opinfo, fixP, now_seg); 567 568 return fixP; 569 } 570 571 /* Return BFD reloc type from opinfo field in a fixS. 572 It's tricky using fx_r_type in iq2000_frob_file because the values 573 are BFD_RELOC_UNUSED + operand number. */ 574 #define FX_OPINFO_R_TYPE(f) ((f)->fx_cgen.opinfo) 575 576 /* Sort any unmatched HI16 relocs so that they immediately precede 577 the corresponding LO16 reloc. This is called before md_apply_fix and 578 tc_gen_reloc. */ 579 580 void 581 iq2000_frob_file (void) 582 { 583 struct iq2000_hi_fixup * l; 584 585 for (l = iq2000_hi_fixup_list; l != NULL; l = l->next) 586 { 587 segment_info_type * seginfo; 588 int pass; 589 590 assert (FX_OPINFO_R_TYPE (l->fixp) == BFD_RELOC_HI16 591 || FX_OPINFO_R_TYPE (l->fixp) == BFD_RELOC_LO16); 592 593 /* Check quickly whether the next fixup happens to be a matching low. */ 594 if (l->fixp->fx_next != NULL 595 && FX_OPINFO_R_TYPE (l->fixp->fx_next) == BFD_RELOC_LO16 596 && l->fixp->fx_addsy == l->fixp->fx_next->fx_addsy 597 && l->fixp->fx_offset == l->fixp->fx_next->fx_offset) 598 continue; 599 600 /* Look through the fixups for this segment for a matching 601 `low'. When we find one, move the high just in front of it. 602 We do this in two passes. In the first pass, we try to find 603 a unique `low'. In the second pass, we permit multiple 604 high's relocs for a single `low'. */ 605 seginfo = seg_info (l->seg); 606 for (pass = 0; pass < 2; pass++) 607 { 608 fixS * f; 609 fixS * prev; 610 611 prev = NULL; 612 for (f = seginfo->fix_root; f != NULL; f = f->fx_next) 613 { 614 /* Check whether this is a `low' fixup which matches l->fixp. */ 615 if (FX_OPINFO_R_TYPE (f) == BFD_RELOC_LO16 616 && f->fx_addsy == l->fixp->fx_addsy 617 && f->fx_offset == l->fixp->fx_offset 618 && (pass == 1 619 || prev == NULL 620 || (FX_OPINFO_R_TYPE (prev) != BFD_RELOC_HI16) 621 || prev->fx_addsy != f->fx_addsy 622 || prev->fx_offset != f->fx_offset)) 623 { 624 fixS ** pf; 625 626 /* Move l->fixp before f. */ 627 for (pf = &seginfo->fix_root; 628 * pf != l->fixp; 629 pf = & (* pf)->fx_next) 630 assert (* pf != NULL); 631 632 * pf = l->fixp->fx_next; 633 634 l->fixp->fx_next = f; 635 if (prev == NULL) 636 seginfo->fix_root = l->fixp; 637 else 638 prev->fx_next = l->fixp; 639 640 break; 641 } 642 643 prev = f; 644 } 645 646 if (f != NULL) 647 break; 648 649 if (pass == 1) 650 as_warn_where (l->fixp->fx_file, l->fixp->fx_line, 651 _("Unmatched high relocation")); 652 } 653 } 654 } 655 656 /* See whether we need to force a relocation into the output file. */ 657 658 int 659 iq2000_force_relocation (fixS * fix) 660 { 661 if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT 662 || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY) 663 return 1; 664 665 return 0; 666 } 667 668 /* Handle the .set pseudo-op. */ 669 670 static void 671 s_iq2000_set (int x ATTRIBUTE_UNUSED) 672 { 673 static const char * ignored_arguments [] = 674 { 675 "reorder", 676 "noreorder", 677 "at", 678 "noat", 679 "macro", 680 "nomacro", 681 "move", 682 "novolatile", 683 "nomove", 684 "volatile", 685 "bopt", 686 "nobopt", 687 NULL 688 }; 689 const char ** ignored; 690 char *name = input_line_pointer, ch; 691 char *save_ILP = input_line_pointer; 692 693 while (!is_end_of_line[(unsigned char) *input_line_pointer]) 694 input_line_pointer++; 695 ch = *input_line_pointer; 696 *input_line_pointer = '\0'; 697 698 for (ignored = ignored_arguments; * ignored; ignored ++) 699 if (strcmp (* ignored, name) == 0) 700 break; 701 if (* ignored == NULL) 702 { 703 /* We'd like to be able to use .set symbol, expn */ 704 input_line_pointer = save_ILP; 705 s_set (0); 706 return; 707 } 708 *input_line_pointer = ch; 709 demand_empty_rest_of_line (); 710 } 711 712 /* Write a value out to the object file, using the appropriate endianness. */ 713 714 void 715 md_number_to_chars (char * buf, valueT val, int n) 716 { 717 number_to_chars_bigendian (buf, val, n); 718 } 719 720 void 721 md_operand (expressionS * exp) 722 { 723 /* In case of a syntax error, escape back to try next syntax combo. */ 724 if (exp->X_op == O_absent) 725 gas_cgen_md_operand (exp); 726 } 727 728 char * 729 md_atof (int type, char * litP, int * sizeP) 730 { 731 return ieee_md_atof (type, litP, sizeP, TRUE); 732 } 733 734 bfd_boolean 735 iq2000_fix_adjustable (fixS * fixP) 736 { 737 bfd_reloc_code_real_type reloc_type; 738 739 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED) 740 { 741 const CGEN_INSN *insn = NULL; 742 int opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED; 743 const CGEN_OPERAND *operand = cgen_operand_lookup_by_num(gas_cgen_cpu_desc, opindex); 744 745 reloc_type = md_cgen_lookup_reloc (insn, operand, fixP); 746 } 747 else 748 reloc_type = fixP->fx_r_type; 749 750 if (fixP->fx_addsy == NULL) 751 return TRUE; 752 753 /* Prevent all adjustments to global symbols. */ 754 if (S_IS_EXTERNAL (fixP->fx_addsy)) 755 return FALSE; 756 757 if (S_IS_WEAK (fixP->fx_addsy)) 758 return FALSE; 759 760 /* We need the symbol name for the VTABLE entries. */ 761 if ( reloc_type == BFD_RELOC_VTABLE_INHERIT 762 || reloc_type == BFD_RELOC_VTABLE_ENTRY) 763 return FALSE; 764 765 return TRUE; 766 } 767 768 static void 769 s_change_sec (int sec) 770 { 771 #ifdef OBJ_ELF 772 /* The ELF backend needs to know that we are changing sections, so 773 that .previous works correctly. We could do something like check 774 for a obj_section_change_hook macro, but that might be confusing 775 as it would not be appropriate to use it in the section changing 776 functions in read.c, since obj-elf.c intercepts those. FIXME: 777 This should be cleaner, somehow. */ 778 obj_elf_section_change_hook (); 779 #endif 780 781 switch (sec) 782 { 783 case 't': 784 s_text (0); 785 break; 786 case 'd': 787 case 'r': 788 s_data (0); 789 break; 790 } 791 } 792 793 static symbolS * 794 get_symbol (void) 795 { 796 int c; 797 char *name; 798 symbolS *p; 799 800 name = input_line_pointer; 801 c = get_symbol_end (); 802 p = (symbolS *) symbol_find_or_make (name); 803 *input_line_pointer = c; 804 return p; 805 } 806 807 /* The .end directive. */ 808 809 static void 810 s_iq2000_end (int x ATTRIBUTE_UNUSED) 811 { 812 symbolS *p; 813 int maybe_text; 814 815 if (!is_end_of_line[(unsigned char) *input_line_pointer]) 816 { 817 p = get_symbol (); 818 demand_empty_rest_of_line (); 819 } 820 else 821 p = NULL; 822 823 if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0) 824 maybe_text = 1; 825 else 826 maybe_text = 0; 827 828 if (!maybe_text) 829 as_warn (_(".end not in text section")); 830 831 if (!cur_proc_ptr) 832 { 833 as_warn (_(".end directive without a preceding .ent directive.")); 834 demand_empty_rest_of_line (); 835 return; 836 } 837 838 if (p != NULL) 839 { 840 assert (S_GET_NAME (p)); 841 if (strcmp (S_GET_NAME (p), S_GET_NAME (cur_proc_ptr->isym))) 842 as_warn (_(".end symbol does not match .ent symbol.")); 843 } 844 else 845 as_warn (_(".end directive missing or unknown symbol")); 846 847 cur_proc_ptr = NULL; 848 } 849 850 static int 851 get_number (void) 852 { 853 int negative = 0; 854 long val = 0; 855 856 if (*input_line_pointer == '-') 857 { 858 ++input_line_pointer; 859 negative = 1; 860 } 861 862 if (! ISDIGIT (*input_line_pointer)) 863 as_bad (_("Expected simple number.")); 864 865 if (input_line_pointer[0] == '0') 866 { 867 if (input_line_pointer[1] == 'x') 868 { 869 input_line_pointer += 2; 870 while (ISXDIGIT (*input_line_pointer)) 871 { 872 val <<= 4; 873 val |= hex_value (*input_line_pointer++); 874 } 875 return negative ? -val : val; 876 } 877 else 878 { 879 ++input_line_pointer; 880 881 while (ISDIGIT (*input_line_pointer)) 882 { 883 val <<= 3; 884 val |= *input_line_pointer++ - '0'; 885 } 886 return negative ? -val : val; 887 } 888 } 889 890 if (! ISDIGIT (*input_line_pointer)) 891 { 892 printf (_(" *input_line_pointer == '%c' 0x%02x\n"), 893 *input_line_pointer, *input_line_pointer); 894 as_warn (_("Invalid number")); 895 return -1; 896 } 897 898 while (ISDIGIT (*input_line_pointer)) 899 { 900 val *= 10; 901 val += *input_line_pointer++ - '0'; 902 } 903 904 return negative ? -val : val; 905 } 906 907 /* The .aent and .ent directives. */ 908 909 static void 910 s_iq2000_ent (int aent) 911 { 912 int number = 0; 913 symbolS *symbolP; 914 int maybe_text; 915 916 symbolP = get_symbol (); 917 if (*input_line_pointer == ',') 918 input_line_pointer++; 919 SKIP_WHITESPACE (); 920 if (ISDIGIT (*input_line_pointer) || *input_line_pointer == '-') 921 number = get_number (); 922 923 if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0) 924 maybe_text = 1; 925 else 926 maybe_text = 0; 927 928 if (!maybe_text) 929 as_warn (_(".ent or .aent not in text section.")); 930 931 if (!aent && cur_proc_ptr) 932 as_warn (_("missing `.end'")); 933 934 if (!aent) 935 { 936 cur_proc_ptr = &cur_proc; 937 memset (cur_proc_ptr, '\0', sizeof (procS)); 938 939 cur_proc_ptr->isym = symbolP; 940 941 symbol_get_bfdsym (symbolP)->flags |= BSF_FUNCTION; 942 943 numprocs++; 944 } 945 946 demand_empty_rest_of_line (); 947 } 948 949 /* The .frame directive. If the mdebug section is present (IRIX 5 native) 950 then ecoff.c (ecoff_directive_frame) is used. For embedded targets, 951 s_iq2000_frame is used so that we can set the PDR information correctly. 952 We can't use the ecoff routines because they make reference to the ecoff 953 symbol table (in the mdebug section). */ 954 955 static void 956 s_iq2000_frame (int ignore) 957 { 958 s_ignore (ignore); 959 } 960 961 /* The .fmask and .mask directives. If the mdebug section is present 962 (IRIX 5 native) then ecoff.c (ecoff_directive_mask) is used. For 963 embedded targets, s_iq2000_mask is used so that we can set the PDR 964 information correctly. We can't use the ecoff routines because they 965 make reference to the ecoff symbol table (in the mdebug section). */ 966 967 static void 968 s_iq2000_mask (int reg_type) 969 { 970 s_ignore (reg_type); 971 } 972 973 /* The target specific pseudo-ops which we support. */ 974 const pseudo_typeS md_pseudo_table[] = 975 { 976 { "align", s_align_bytes, 0 }, 977 { "word", cons, 4 }, 978 { "rdata", s_change_sec, 'r'}, 979 { "sdata", s_change_sec, 's'}, 980 { "set", s_iq2000_set, 0 }, 981 { "ent", s_iq2000_ent, 0 }, 982 { "end", s_iq2000_end, 0 }, 983 { "frame", s_iq2000_frame, 0 }, 984 { "fmask", s_iq2000_mask, 'F'}, 985 { "mask", s_iq2000_mask, 'R'}, 986 { "dword", cons, 8 }, 987 { "half", cons, 2 }, 988 { NULL, NULL, 0 } 989 }; 990