1 /* tc-m68k.c -- Assemble for the m68k family 2 Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 4 Free Software Foundation, Inc. 5 6 This file is part of GAS, the GNU Assembler. 7 8 GAS is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3, or (at your option) 11 any later version. 12 13 GAS is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GAS; see the file COPYING. If not, write to the Free 20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 21 02110-1301, USA. */ 22 23 #include "as.h" 24 #include "safe-ctype.h" 25 #include "obstack.h" 26 #include "subsegs.h" 27 #include "dwarf2dbg.h" 28 #include "dw2gencfi.h" 29 30 #include "opcode/m68k.h" 31 #include "m68k-parse.h" 32 33 #if defined (OBJ_ELF) 34 #include "elf/m68k.h" 35 #endif 36 37 #ifdef M68KCOFF 38 #include "obj-coff.h" 39 #endif 40 41 /* This string holds the chars that always start a comment. If the 42 pre-processor is disabled, these aren't very useful. The macro 43 tc_comment_chars points to this. We use this, rather than the 44 usual comment_chars, so that the --bitwise-or option will work. */ 45 #if defined (TE_SVR4) || defined (TE_DELTA) 46 const char *m68k_comment_chars = "|#"; 47 #else 48 const char *m68k_comment_chars = "|"; 49 #endif 50 51 /* This array holds the chars that only start a comment at the beginning of 52 a line. If the line seems to have the form '# 123 filename' 53 .line and .file directives will appear in the pre-processed output */ 54 /* Note that input_file.c hand checks for '#' at the beginning of the 55 first line of the input file. This is because the compiler outputs 56 #NO_APP at the beginning of its output. */ 57 /* Also note that comments like this one will always work. */ 58 const char line_comment_chars[] = "#*"; 59 60 const char line_separator_chars[] = ";"; 61 62 /* Chars that can be used to separate mant from exp in floating point nums. */ 63 const char EXP_CHARS[] = "eE"; 64 65 /* Chars that mean this number is a floating point constant, as 66 in "0f12.456" or "0d1.2345e12". */ 67 68 const char FLT_CHARS[] = "rRsSfFdDxXeEpP"; 69 70 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be 71 changed in read.c . Ideally it shouldn't have to know about it at all, 72 but nothing is ideal around here. */ 73 74 /* Are we trying to generate PIC code? If so, absolute references 75 ought to be made into linkage table references or pc-relative 76 references. Not implemented. For ELF there are other means 77 to denote pic relocations. */ 78 int flag_want_pic; 79 80 static int flag_short_refs; /* -l option. */ 81 static int flag_long_jumps; /* -S option. */ 82 static int flag_keep_pcrel; /* --pcrel option. */ 83 84 #ifdef REGISTER_PREFIX_OPTIONAL 85 int flag_reg_prefix_optional = REGISTER_PREFIX_OPTIONAL; 86 #else 87 int flag_reg_prefix_optional; 88 #endif 89 90 /* Whether --register-prefix-optional was used on the command line. */ 91 static int reg_prefix_optional_seen; 92 93 /* The floating point coprocessor to use by default. */ 94 static enum m68k_register m68k_float_copnum = COP1; 95 96 /* If this is non-zero, then references to number(%pc) will be taken 97 to refer to number, rather than to %pc + number. */ 98 static int m68k_abspcadd; 99 100 /* If this is non-zero, then the quick forms of the move, add, and sub 101 instructions are used when possible. */ 102 static int m68k_quick = 1; 103 104 /* If this is non-zero, then if the size is not specified for a base 105 or outer displacement, the assembler assumes that the size should 106 be 32 bits. */ 107 static int m68k_rel32 = 1; 108 109 /* This is non-zero if m68k_rel32 was set from the command line. */ 110 static int m68k_rel32_from_cmdline; 111 112 /* The default width to use for an index register when using a base 113 displacement. */ 114 static enum m68k_size m68k_index_width_default = SIZE_LONG; 115 116 /* We want to warn if any text labels are misaligned. In order to get 117 the right line number, we need to record the line number for each 118 label. */ 119 struct label_line 120 { 121 struct label_line *next; 122 symbolS *label; 123 char *file; 124 unsigned int line; 125 int text; 126 }; 127 128 /* The list of labels. */ 129 130 static struct label_line *labels; 131 132 /* The current label. */ 133 134 static struct label_line *current_label; 135 136 /* Pointer to list holding the opcodes sorted by name. */ 137 static struct m68k_opcode const ** m68k_sorted_opcodes; 138 139 /* Its an arbitrary name: This means I don't approve of it. 140 See flames below. */ 141 static struct obstack robyn; 142 143 struct m68k_incant 144 { 145 const char *m_operands; 146 unsigned long m_opcode; 147 short m_opnum; 148 short m_codenum; 149 int m_arch; 150 struct m68k_incant *m_next; 151 }; 152 153 #define getone(x) ((((x)->m_opcode)>>16)&0xffff) 154 #define gettwo(x) (((x)->m_opcode)&0xffff) 155 156 static const enum m68k_register m68000_ctrl[] = { 0 }; 157 static const enum m68k_register m68010_ctrl[] = { 158 SFC, DFC, USP, VBR, 159 0 160 }; 161 static const enum m68k_register m68020_ctrl[] = { 162 SFC, DFC, USP, VBR, CACR, CAAR, MSP, ISP, 163 0 164 }; 165 static const enum m68k_register m68040_ctrl[] = { 166 SFC, DFC, CACR, TC, ITT0, ITT1, DTT0, DTT1, 167 USP, VBR, MSP, ISP, MMUSR, URP, SRP, 168 0 169 }; 170 static const enum m68k_register m68060_ctrl[] = { 171 SFC, DFC, CACR, TC, ITT0, ITT1, DTT0, DTT1, BUSCR, 172 USP, VBR, URP, SRP, PCR, 173 0 174 }; 175 static const enum m68k_register mcf_ctrl[] = { 176 CACR, TC, ACR0, ACR1, ACR2, ACR3, VBR, ROMBAR, 177 RAMBAR0, RAMBAR1, RAMBAR, MBAR, 178 0 179 }; 180 static const enum m68k_register mcf51qe_ctrl[] = { 181 VBR, 182 0 183 }; 184 static const enum m68k_register mcf5206_ctrl[] = { 185 CACR, ACR0, ACR1, VBR, RAMBAR0, RAMBAR_ALT, MBAR, 186 0 187 }; 188 static const enum m68k_register mcf5208_ctrl[] = { 189 CACR, ACR0, ACR1, VBR, RAMBAR, RAMBAR1, 190 0 191 }; 192 static const enum m68k_register mcf5210a_ctrl[] = { 193 VBR, CACR, ACR0, ACR1, ROMBAR, RAMBAR, RAMBAR1, MBAR, 194 0 195 }; 196 static const enum m68k_register mcf5213_ctrl[] = { 197 VBR, RAMBAR, RAMBAR1, FLASHBAR, 198 0 199 }; 200 static const enum m68k_register mcf5216_ctrl[] = { 201 VBR, CACR, ACR0, ACR1, FLASHBAR, RAMBAR, RAMBAR1, 202 0 203 }; 204 static const enum m68k_register mcf52223_ctrl[] = { 205 VBR, CACR, ACR0, ACR1, FLASHBAR, RAMBAR, RAMBAR1, 206 0 207 }; 208 static const enum m68k_register mcf52235_ctrl[] = { 209 VBR, CACR, ACR0, ACR1, FLASHBAR, RAMBAR, RAMBAR1, 210 0 211 }; 212 static const enum m68k_register mcf5225_ctrl[] = { 213 VBR, CACR, ACR0, ACR1, FLASHBAR, RAMBAR, MBAR, RAMBAR1, 214 0 215 }; 216 static const enum m68k_register mcf5235_ctrl[] = { 217 VBR, CACR, ACR0, ACR1, RAMBAR, RAMBAR1, 218 0 219 }; 220 static const enum m68k_register mcf5249_ctrl[] = { 221 VBR, CACR, ACR0, ACR1, RAMBAR0, RAMBAR1, RAMBAR, MBAR, MBAR2, 222 0 223 }; 224 static const enum m68k_register mcf5250_ctrl[] = { 225 VBR, 226 0 227 }; 228 static const enum m68k_register mcf5253_ctrl[] = { 229 VBR, CACR, ACR0, ACR1, RAMBAR0, RAMBAR1, RAMBAR, MBAR, MBAR2, 230 0 231 }; 232 static const enum m68k_register mcf5271_ctrl[] = { 233 VBR, CACR, ACR0, ACR1, RAMBAR, RAMBAR1, 234 0 235 }; 236 static const enum m68k_register mcf5272_ctrl[] = { 237 VBR, CACR, ACR0, ACR1, ROMBAR, RAMBAR_ALT, RAMBAR0, MBAR, 238 0 239 }; 240 static const enum m68k_register mcf5275_ctrl[] = { 241 VBR, CACR, ACR0, ACR1, RAMBAR, RAMBAR1, 242 0 243 }; 244 static const enum m68k_register mcf5282_ctrl[] = { 245 VBR, CACR, ACR0, ACR1, FLASHBAR, RAMBAR, RAMBAR1, 246 0 247 }; 248 static const enum m68k_register mcf5307_ctrl[] = { 249 CACR, ACR0, ACR1, VBR, RAMBAR0, RAMBAR_ALT, MBAR, 250 0 251 }; 252 static const enum m68k_register mcf5329_ctrl[] = { 253 VBR, CACR, ACR0, ACR1, RAMBAR, RAMBAR1, 254 0 255 }; 256 static const enum m68k_register mcf5373_ctrl[] = { 257 VBR, CACR, ACR0, ACR1, RAMBAR, RAMBAR1, 258 0 259 }; 260 static const enum m68k_register mcfv4e_ctrl[] = { 261 CACR, ASID, ACR0, ACR1, ACR2, ACR3, MMUBAR, 262 VBR, PC, ROMBAR0, ROMBAR1, RAMBAR0, RAMBAR1, 263 MBAR, SECMBAR, 264 MPCR /* Multiprocessor Control register */, 265 EDRAMBAR /* Embedded DRAM Base Address Register */, 266 /* Permutation control registers. */ 267 PCR1U0, PCR1L0, PCR1U1, PCR1L1, PCR2U0, PCR2L0, PCR2U1, PCR2L1, 268 PCR3U0, PCR3L0, PCR3U1, PCR3L1, 269 /* Legacy names */ 270 TC /* ASID */, BUSCR /* MMUBAR */, 271 ITT0 /* ACR0 */, ITT1 /* ACR1 */, DTT0 /* ACR2 */, DTT1 /* ACR3 */, 272 MBAR1 /* MBAR */, MBAR2 /* SECMBAR */, MBAR0 /* SECMBAR */, 273 ROMBAR /* ROMBAR0 */, RAMBAR /* RAMBAR1 */, 274 0 275 }; 276 static const enum m68k_register mcf5407_ctrl[] = { 277 CACR, ASID, ACR0, ACR1, ACR2, ACR3, 278 VBR, PC, RAMBAR0, RAMBAR1, MBAR, 279 /* Legacy names */ 280 TC /* ASID */, 281 ITT0 /* ACR0 */, ITT1 /* ACR1 */, DTT0 /* ACR2 */, DTT1 /* ACR3 */, 282 MBAR1 /* MBAR */, RAMBAR /* RAMBAR1 */, 283 0 284 }; 285 static const enum m68k_register mcf54455_ctrl[] = { 286 CACR, ASID, ACR0, ACR1, ACR2, ACR3, MMUBAR, 287 VBR, PC, RAMBAR1, MBAR, 288 /* Legacy names */ 289 TC /* ASID */, BUSCR /* MMUBAR */, 290 ITT0 /* ACR0 */, ITT1 /* ACR1 */, DTT0 /* ACR2 */, DTT1 /* ACR3 */, 291 MBAR1 /* MBAR */, RAMBAR /* RAMBAR1 */, 292 0 293 }; 294 static const enum m68k_register mcf5475_ctrl[] = { 295 CACR, ASID, ACR0, ACR1, ACR2, ACR3, MMUBAR, 296 VBR, PC, RAMBAR0, RAMBAR1, MBAR, 297 /* Legacy names */ 298 TC /* ASID */, BUSCR /* MMUBAR */, 299 ITT0 /* ACR0 */, ITT1 /* ACR1 */, DTT0 /* ACR2 */, DTT1 /* ACR3 */, 300 MBAR1 /* MBAR */, RAMBAR /* RAMBAR1 */, 301 0 302 }; 303 static const enum m68k_register mcf5485_ctrl[] = { 304 CACR, ASID, ACR0, ACR1, ACR2, ACR3, MMUBAR, 305 VBR, PC, RAMBAR0, RAMBAR1, MBAR, 306 /* Legacy names */ 307 TC /* ASID */, BUSCR /* MMUBAR */, 308 ITT0 /* ACR0 */, ITT1 /* ACR1 */, DTT0 /* ACR2 */, DTT1 /* ACR3 */, 309 MBAR1 /* MBAR */, RAMBAR /* RAMBAR1 */, 310 0 311 }; 312 static const enum m68k_register fido_ctrl[] = { 313 SFC, DFC, USP, VBR, CAC, MBO, 314 0 315 }; 316 #define cpu32_ctrl m68010_ctrl 317 318 static const enum m68k_register *control_regs; 319 320 /* Internal form of a 68020 instruction. */ 321 struct m68k_it 322 { 323 const char *error; 324 const char *args; /* List of opcode info. */ 325 int numargs; 326 327 int numo; /* Number of shorts in opcode. */ 328 short opcode[11]; 329 330 struct m68k_op operands[6]; 331 332 int nexp; /* Number of exprs in use. */ 333 struct m68k_exp exprs[4]; 334 335 int nfrag; /* Number of frags we have to produce. */ 336 struct 337 { 338 int fragoff; /* Where in the current opcode the frag ends. */ 339 symbolS *fadd; 340 offsetT foff; 341 int fragty; 342 } 343 fragb[4]; 344 345 int nrel; /* Num of reloc strucs in use. */ 346 struct 347 { 348 int n; 349 expressionS exp; 350 char wid; 351 char pcrel; 352 /* In a pc relative address the difference between the address 353 of the offset and the address that the offset is relative 354 to. This depends on the addressing mode. Basically this 355 is the value to put in the offset field to address the 356 first byte of the offset, without regarding the special 357 significance of some values (in the branch instruction, for 358 example). */ 359 int pcrel_fix; 360 #ifdef OBJ_ELF 361 /* Whether this expression needs special pic relocation, and if 362 so, which. */ 363 enum pic_relocation pic_reloc; 364 #endif 365 } 366 reloc[5]; /* Five is enough??? */ 367 }; 368 369 #define cpu_of_arch(x) ((x) & (m68000up | mcfisa_a | fido_a)) 370 #define float_of_arch(x) ((x) & mfloat) 371 #define mmu_of_arch(x) ((x) & mmmu) 372 #define arch_coldfire_p(x) ((x) & mcfisa_a) 373 #define arch_coldfire_fpu(x) ((x) & cfloat) 374 375 /* Macros for determining if cpu supports a specific addressing mode. */ 376 #define HAVE_LONG_DISP(x) \ 377 ((x) & (m68020|m68030|m68040|m68060|cpu32|fido_a|mcfisa_b|mcfisa_c)) 378 #define HAVE_LONG_CALL(x) \ 379 ((x) & (m68020|m68030|m68040|m68060|cpu32|fido_a|mcfisa_b|mcfisa_c)) 380 #define HAVE_LONG_COND(x) \ 381 ((x) & (m68020|m68030|m68040|m68060|cpu32|fido_a|mcfisa_b|mcfisa_c)) 382 #define HAVE_LONG_BRANCH(x) \ 383 ((x) & (m68020|m68030|m68040|m68060|cpu32|fido_a|mcfisa_b)) 384 #define LONG_BRANCH_VIA_COND(x) (HAVE_LONG_COND(x) && !HAVE_LONG_BRANCH(x)) 385 386 static struct m68k_it the_ins; /* The instruction being assembled. */ 387 388 #define op(ex) ((ex)->exp.X_op) 389 #define adds(ex) ((ex)->exp.X_add_symbol) 390 #define subs(ex) ((ex)->exp.X_op_symbol) 391 #define offs(ex) ((ex)->exp.X_add_number) 392 393 /* Macros for adding things to the m68k_it struct. */ 394 #define addword(w) (the_ins.opcode[the_ins.numo++] = (w)) 395 396 /* Like addword, but goes BEFORE general operands. */ 397 398 static void 399 insop (int w, const struct m68k_incant *opcode) 400 { 401 int z; 402 for (z = the_ins.numo; z > opcode->m_codenum; --z) 403 the_ins.opcode[z] = the_ins.opcode[z - 1]; 404 for (z = 0; z < the_ins.nrel; z++) 405 the_ins.reloc[z].n += 2; 406 for (z = 0; z < the_ins.nfrag; z++) 407 the_ins.fragb[z].fragoff++; 408 the_ins.opcode[opcode->m_codenum] = w; 409 the_ins.numo++; 410 } 411 412 /* The numo+1 kludge is so we can hit the low order byte of the prev word. 413 Blecch. */ 414 static void 415 add_fix (int width, struct m68k_exp *exp, int pc_rel, int pc_fix) 416 { 417 the_ins.reloc[the_ins.nrel].n = (width == 'B' || width == '3' 418 ? the_ins.numo * 2 - 1 419 : (width == 'b' 420 ? the_ins.numo * 2 + 1 421 : the_ins.numo * 2)); 422 the_ins.reloc[the_ins.nrel].exp = exp->exp; 423 the_ins.reloc[the_ins.nrel].wid = width; 424 the_ins.reloc[the_ins.nrel].pcrel_fix = pc_fix; 425 #ifdef OBJ_ELF 426 the_ins.reloc[the_ins.nrel].pic_reloc = exp->pic_reloc; 427 #endif 428 the_ins.reloc[the_ins.nrel++].pcrel = pc_rel; 429 } 430 431 /* Cause an extra frag to be generated here, inserting up to 10 bytes 432 (that value is chosen in the frag_var call in md_assemble). TYPE 433 is the subtype of the frag to be generated; its primary type is 434 rs_machine_dependent. 435 436 The TYPE parameter is also used by md_convert_frag_1 and 437 md_estimate_size_before_relax. The appropriate type of fixup will 438 be emitted by md_convert_frag_1. 439 440 ADD becomes the FR_SYMBOL field of the frag, and OFF the FR_OFFSET. */ 441 static void 442 add_frag (symbolS *add, offsetT off, int type) 443 { 444 the_ins.fragb[the_ins.nfrag].fragoff = the_ins.numo; 445 the_ins.fragb[the_ins.nfrag].fadd = add; 446 the_ins.fragb[the_ins.nfrag].foff = off; 447 the_ins.fragb[the_ins.nfrag++].fragty = type; 448 } 449 450 #define isvar(ex) \ 451 (op (ex) != O_constant && op (ex) != O_big) 452 453 static char *crack_operand (char *str, struct m68k_op *opP); 454 static int get_num (struct m68k_exp *exp, int ok); 455 static int reverse_16_bits (int in); 456 static int reverse_8_bits (int in); 457 static void install_gen_operand (int mode, int val); 458 static void install_operand (int mode, int val); 459 static void s_bss (int); 460 static void s_data1 (int); 461 static void s_data2 (int); 462 static void s_even (int); 463 static void s_proc (int); 464 static void s_chip (int); 465 static void s_fopt (int); 466 static void s_opt (int); 467 static void s_reg (int); 468 static void s_restore (int); 469 static void s_save (int); 470 static void s_mri_if (int); 471 static void s_mri_else (int); 472 static void s_mri_endi (int); 473 static void s_mri_break (int); 474 static void s_mri_next (int); 475 static void s_mri_for (int); 476 static void s_mri_endf (int); 477 static void s_mri_repeat (int); 478 static void s_mri_until (int); 479 static void s_mri_while (int); 480 static void s_mri_endw (int); 481 static void s_m68k_cpu (int); 482 static void s_m68k_arch (int); 483 484 struct m68k_cpu 485 { 486 unsigned long arch; /* Architecture features. */ 487 const enum m68k_register *control_regs; /* Control regs on chip */ 488 const char *name; /* Name */ 489 int alias; /* Alias for a cannonical name. If 1, then 490 succeeds canonical name, if -1 then 491 succeeds canonical name, if <-1 ||>1 this is a 492 deprecated name, and the next/previous name 493 should be used. */ 494 }; 495 496 /* We hold flags for features explicitly enabled and explicitly 497 disabled. */ 498 static int current_architecture; 499 static int not_current_architecture; 500 static const struct m68k_cpu *selected_arch; 501 static const struct m68k_cpu *selected_cpu; 502 static int initialized; 503 504 /* Architecture models. */ 505 static const struct m68k_cpu m68k_archs[] = 506 { 507 {m68000, m68000_ctrl, "68000", 0}, 508 {m68010, m68010_ctrl, "68010", 0}, 509 {m68020|m68881|m68851, m68020_ctrl, "68020", 0}, 510 {m68030|m68881|m68851, m68020_ctrl, "68030", 0}, 511 {m68040, m68040_ctrl, "68040", 0}, 512 {m68060, m68060_ctrl, "68060", 0}, 513 {cpu32|m68881, cpu32_ctrl, "cpu32", 0}, 514 {fido_a, fido_ctrl, "fidoa", 0}, 515 {mcfisa_a|mcfhwdiv, NULL, "isaa", 0}, 516 {mcfisa_a|mcfhwdiv|mcfisa_aa|mcfusp, NULL, "isaaplus", 0}, 517 {mcfisa_a|mcfhwdiv|mcfisa_b|mcfusp, NULL, "isab", 0}, 518 {mcfisa_a|mcfhwdiv|mcfisa_c|mcfusp, NULL, "isac", 0}, 519 {mcfisa_a|mcfhwdiv|mcfisa_b|mcfmac|mcfusp, mcf_ctrl, "cfv4", 0}, 520 {mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat, mcfv4e_ctrl, "cfv4e", 0}, 521 {0,0,NULL, 0} 522 }; 523 524 /* Architecture extensions, here 'alias' -1 for m68k, +1 for cf and 0 525 for either. */ 526 static const struct m68k_cpu m68k_extensions[] = 527 { 528 {m68851, NULL, "68851", -1}, 529 {m68881, NULL, "68881", -1}, 530 {m68881, NULL, "68882", -1}, 531 532 {cfloat|m68881, NULL, "float", 0}, 533 534 {mcfhwdiv, NULL, "div", 1}, 535 {mcfusp, NULL, "usp", 1}, 536 {mcfmac, NULL, "mac", 1}, 537 {mcfemac, NULL, "emac", 1}, 538 539 {0,NULL,NULL, 0} 540 }; 541 542 /* Processor list */ 543 static const struct m68k_cpu m68k_cpus[] = 544 { 545 {m68000, m68000_ctrl, "68000", 0}, 546 {m68000, m68000_ctrl, "68ec000", 1}, 547 {m68000, m68000_ctrl, "68hc000", 1}, 548 {m68000, m68000_ctrl, "68hc001", 1}, 549 {m68000, m68000_ctrl, "68008", 1}, 550 {m68000, m68000_ctrl, "68302", 1}, 551 {m68000, m68000_ctrl, "68306", 1}, 552 {m68000, m68000_ctrl, "68307", 1}, 553 {m68000, m68000_ctrl, "68322", 1}, 554 {m68000, m68000_ctrl, "68356", 1}, 555 {m68010, m68010_ctrl, "68010", 0}, 556 {m68020|m68881|m68851, m68020_ctrl, "68020", 0}, 557 {m68020|m68881|m68851, m68020_ctrl, "68k", 1}, 558 {m68020|m68881|m68851, m68020_ctrl, "68ec020", 1}, 559 {m68030|m68881|m68851, m68020_ctrl, "68030", 0}, 560 {m68030|m68881|m68851, m68020_ctrl, "68ec030", 1}, 561 {m68040, m68040_ctrl, "68040", 0}, 562 {m68040, m68040_ctrl, "68ec040", 1}, 563 {m68060, m68060_ctrl, "68060", 0}, 564 {m68060, m68060_ctrl, "68ec060", 1}, 565 566 {cpu32|m68881, cpu32_ctrl, "cpu32", 0}, 567 {cpu32|m68881, cpu32_ctrl, "68330", 1}, 568 {cpu32|m68881, cpu32_ctrl, "68331", 1}, 569 {cpu32|m68881, cpu32_ctrl, "68332", 1}, 570 {cpu32|m68881, cpu32_ctrl, "68333", 1}, 571 {cpu32|m68881, cpu32_ctrl, "68334", 1}, 572 {cpu32|m68881, cpu32_ctrl, "68336", 1}, 573 {cpu32|m68881, cpu32_ctrl, "68340", 1}, 574 {cpu32|m68881, cpu32_ctrl, "68341", 1}, 575 {cpu32|m68881, cpu32_ctrl, "68349", 1}, 576 {cpu32|m68881, cpu32_ctrl, "68360", 1}, 577 578 {mcfisa_a|mcfisa_c|mcfusp, mcf51qe_ctrl, "51qe", 0}, 579 580 {mcfisa_a, mcf_ctrl, "5200", 0}, 581 {mcfisa_a, mcf_ctrl, "5202", 1}, 582 {mcfisa_a, mcf_ctrl, "5204", 1}, 583 {mcfisa_a, mcf5206_ctrl, "5206", 1}, 584 585 {mcfisa_a|mcfhwdiv|mcfmac, mcf5206_ctrl, "5206e", 0}, 586 587 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5208_ctrl, "5207", -1}, 588 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5208_ctrl, "5208", 0}, 589 590 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfmac|mcfusp, mcf5210a_ctrl, "5210a", 0}, 591 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfmac|mcfusp, mcf5210a_ctrl, "5211a", 1}, 592 593 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfmac|mcfusp, mcf5213_ctrl, "5211", -1}, 594 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfmac|mcfusp, mcf5213_ctrl, "5212", -1}, 595 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfmac|mcfusp, mcf5213_ctrl, "5213", 0}, 596 597 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5216_ctrl, "5214", -1}, 598 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5216_ctrl, "5216", 0}, 599 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5216_ctrl, "521x", 2}, 600 601 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfmac|mcfusp, mcf52223_ctrl, "52221", -1}, 602 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfmac|mcfusp, mcf52223_ctrl, "52223", 0}, 603 604 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf52235_ctrl, "52230", -1}, 605 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf52235_ctrl, "52233", -1}, 606 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf52235_ctrl, "52234", -1}, 607 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf52235_ctrl, "52235", 0}, 608 609 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfmac|mcfusp, mcf5225_ctrl, "5224", -1}, 610 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfmac|mcfusp, mcf5225_ctrl, "5225", 0}, 611 612 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5235_ctrl, "5232", -1}, 613 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5235_ctrl, "5233", -1}, 614 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5235_ctrl, "5234", -1}, 615 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5235_ctrl, "5235", -1}, 616 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5235_ctrl, "523x", 0}, 617 618 {mcfisa_a|mcfhwdiv|mcfemac, mcf5249_ctrl, "5249", 0}, 619 {mcfisa_a|mcfhwdiv|mcfemac, mcf5250_ctrl, "5250", 0}, 620 {mcfisa_a|mcfhwdiv|mcfemac, mcf5253_ctrl, "5253", 0}, 621 622 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5271_ctrl, "5270", -1}, 623 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5271_ctrl, "5271", 0}, 624 625 {mcfisa_a|mcfhwdiv|mcfmac, mcf5272_ctrl, "5272", 0}, 626 627 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5275_ctrl, "5274", -1}, 628 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5275_ctrl, "5275", 0}, 629 630 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5282_ctrl, "5280", -1}, 631 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5282_ctrl, "5281", -1}, 632 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5282_ctrl, "5282", -1}, 633 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5282_ctrl, "528x", 0}, 634 635 {mcfisa_a|mcfhwdiv|mcfmac, mcf5307_ctrl, "5307", 0}, 636 637 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5329_ctrl, "5327", -1}, 638 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5329_ctrl, "5328", -1}, 639 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5329_ctrl, "5329", -1}, 640 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5329_ctrl, "532x", 0}, 641 642 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5373_ctrl, "5372", -1}, 643 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5373_ctrl, "5373", -1}, 644 {mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf5373_ctrl, "537x", 0}, 645 646 {mcfisa_a|mcfisa_b|mcfhwdiv|mcfmac, mcf5407_ctrl, "5407",0}, 647 648 {mcfisa_a|mcfisa_c|mcfhwdiv|mcfemac|mcfusp, mcf54455_ctrl, "54450", -1}, 649 {mcfisa_a|mcfisa_c|mcfhwdiv|mcfemac|mcfusp, mcf54455_ctrl, "54451", -1}, 650 {mcfisa_a|mcfisa_c|mcfhwdiv|mcfemac|mcfusp, mcf54455_ctrl, "54452", -1}, 651 {mcfisa_a|mcfisa_c|mcfhwdiv|mcfemac|mcfusp, mcf54455_ctrl, "54453", -1}, 652 {mcfisa_a|mcfisa_c|mcfhwdiv|mcfemac|mcfusp, mcf54455_ctrl, "54454", -1}, 653 {mcfisa_a|mcfisa_c|mcfhwdiv|mcfemac|mcfusp, mcf54455_ctrl, "54455", 0}, 654 655 {mcfisa_a|mcfisa_b|mcfhwdiv|mcfemac|mcfusp|cfloat, mcf5475_ctrl, "5470", -1}, 656 {mcfisa_a|mcfisa_b|mcfhwdiv|mcfemac|mcfusp|cfloat, mcf5475_ctrl, "5471", -1}, 657 {mcfisa_a|mcfisa_b|mcfhwdiv|mcfemac|mcfusp|cfloat, mcf5475_ctrl, "5472", -1}, 658 {mcfisa_a|mcfisa_b|mcfhwdiv|mcfemac|mcfusp|cfloat, mcf5475_ctrl, "5473", -1}, 659 {mcfisa_a|mcfisa_b|mcfhwdiv|mcfemac|mcfusp|cfloat, mcf5475_ctrl, "5474", -1}, 660 {mcfisa_a|mcfisa_b|mcfhwdiv|mcfemac|mcfusp|cfloat, mcf5475_ctrl, "5475", -1}, 661 {mcfisa_a|mcfisa_b|mcfhwdiv|mcfemac|mcfusp|cfloat, mcf5475_ctrl, "547x", 0}, 662 663 {mcfisa_a|mcfisa_b|mcfhwdiv|mcfemac|mcfusp|cfloat, mcf5485_ctrl, "5480", -1}, 664 {mcfisa_a|mcfisa_b|mcfhwdiv|mcfemac|mcfusp|cfloat, mcf5485_ctrl, "5481", -1}, 665 {mcfisa_a|mcfisa_b|mcfhwdiv|mcfemac|mcfusp|cfloat, mcf5485_ctrl, "5482", -1}, 666 {mcfisa_a|mcfisa_b|mcfhwdiv|mcfemac|mcfusp|cfloat, mcf5485_ctrl, "5483", -1}, 667 {mcfisa_a|mcfisa_b|mcfhwdiv|mcfemac|mcfusp|cfloat, mcf5485_ctrl, "5484", -1}, 668 {mcfisa_a|mcfisa_b|mcfhwdiv|mcfemac|mcfusp|cfloat, mcf5485_ctrl, "5485", -1}, 669 {mcfisa_a|mcfisa_b|mcfhwdiv|mcfemac|mcfusp|cfloat, mcf5485_ctrl, "548x", 0}, 670 671 {fido_a, fido_ctrl, "fidoa", 0}, 672 {fido_a, fido_ctrl, "fido", 1}, 673 674 {0,NULL,NULL, 0} 675 }; 676 677 static const struct m68k_cpu *m68k_lookup_cpu 678 (const char *, const struct m68k_cpu *, int, int *); 679 static int m68k_set_arch (const char *, int, int); 680 static int m68k_set_cpu (const char *, int, int); 681 static int m68k_set_extension (const char *, int, int); 682 static void m68k_init_arch (void); 683 684 /* This is the assembler relaxation table for m68k. m68k is a rich CISC 685 architecture and we have a lot of relaxation modes. */ 686 687 /* Macros used in the relaxation code. */ 688 #define TAB(x,y) (((x) << 2) + (y)) 689 #define TABTYPE(x) ((x) >> 2) 690 691 /* Relaxation states. */ 692 #define BYTE 0 693 #define SHORT 1 694 #define LONG 2 695 #define SZ_UNDEF 3 696 697 /* Here are all the relaxation modes we support. First we can relax ordinary 698 branches. On 68020 and higher and on CPU32 all branch instructions take 699 three forms, so on these CPUs all branches always remain as such. When we 700 have to expand to the LONG form on a 68000, though, we substitute an 701 absolute jump instead. This is a direct replacement for unconditional 702 branches and a branch over a jump for conditional branches. However, if the 703 user requires PIC and disables this with --pcrel, we can only relax between 704 BYTE and SHORT forms, punting if that isn't enough. This gives us four 705 different relaxation modes for branches: */ 706 707 #define BRANCHBWL 0 /* Branch byte, word, or long. */ 708 #define BRABSJUNC 1 /* Absolute jump for LONG, unconditional. */ 709 #define BRABSJCOND 2 /* Absolute jump for LONG, conditional. */ 710 #define BRANCHBW 3 /* Branch byte or word. */ 711 712 /* We also relax coprocessor branches and DBcc's. All CPUs that support 713 coprocessor branches support them in word and long forms, so we have only 714 one relaxation mode for them. DBcc's are word only on all CPUs. We can 715 relax them to the LONG form with a branch-around sequence. This sequence 716 can use a long branch (if available) or an absolute jump (if acceptable). 717 This gives us two relaxation modes. If long branches are not available and 718 absolute jumps are not acceptable, we don't relax DBcc's. */ 719 720 #define FBRANCH 4 /* Coprocessor branch. */ 721 #define DBCCLBR 5 /* DBcc relaxable with a long branch. */ 722 #define DBCCABSJ 6 /* DBcc relaxable with an absolute jump. */ 723 724 /* That's all for instruction relaxation. However, we also relax PC-relative 725 operands. Specifically, we have three operand relaxation modes. On the 726 68000 PC-relative operands can only be 16-bit, but on 68020 and higher and 727 on CPU32 they may be 16-bit or 32-bit. For the latter we relax between the 728 two. Also PC+displacement+index operands in their simple form (with a non- 729 suppressed index without memory indirection) are supported on all CPUs, but 730 on the 68000 the displacement can be 8-bit only, whereas on 68020 and higher 731 and on CPU32 we relax it to SHORT and LONG forms as well using the extended 732 form of the PC+displacement+index operand. Finally, some absolute operands 733 can be relaxed down to 16-bit PC-relative. */ 734 735 #define PCREL1632 7 /* 16-bit or 32-bit PC-relative. */ 736 #define PCINDEX 8 /* PC + displacement + index. */ 737 #define ABSTOPCREL 9 /* Absolute relax down to 16-bit PC-relative. */ 738 739 /* This relaxation is required for branches where there is no long 740 branch and we are in pcrel mode. We generate a bne/beq pair. */ 741 #define BRANCHBWPL 10 /* Branch byte, word or pair of longs 742 */ 743 744 /* Note that calls to frag_var need to specify the maximum expansion 745 needed; this is currently 12 bytes for bne/beq pair. */ 746 #define FRAG_VAR_SIZE 12 747 748 /* The fields are: 749 How far Forward this mode will reach: 750 How far Backward this mode will reach: 751 How many bytes this mode will add to the size of the frag 752 Which mode to go to if the offset won't fit in this one 753 754 Please check tc-m68k.h:md_prepare_relax_scan if changing this table. */ 755 relax_typeS md_relax_table[] = 756 { 757 { 127, -128, 0, TAB (BRANCHBWL, SHORT) }, 758 { 32767, -32768, 2, TAB (BRANCHBWL, LONG) }, 759 { 0, 0, 4, 0 }, 760 { 1, 1, 0, 0 }, 761 762 { 127, -128, 0, TAB (BRABSJUNC, SHORT) }, 763 { 32767, -32768, 2, TAB (BRABSJUNC, LONG) }, 764 { 0, 0, 4, 0 }, 765 { 1, 1, 0, 0 }, 766 767 { 127, -128, 0, TAB (BRABSJCOND, SHORT) }, 768 { 32767, -32768, 2, TAB (BRABSJCOND, LONG) }, 769 { 0, 0, 6, 0 }, 770 { 1, 1, 0, 0 }, 771 772 { 127, -128, 0, TAB (BRANCHBW, SHORT) }, 773 { 0, 0, 2, 0 }, 774 { 1, 1, 0, 0 }, 775 { 1, 1, 0, 0 }, 776 777 { 1, 1, 0, 0 }, /* FBRANCH doesn't come BYTE. */ 778 { 32767, -32768, 2, TAB (FBRANCH, LONG) }, 779 { 0, 0, 4, 0 }, 780 { 1, 1, 0, 0 }, 781 782 { 1, 1, 0, 0 }, /* DBCC doesn't come BYTE. */ 783 { 32767, -32768, 2, TAB (DBCCLBR, LONG) }, 784 { 0, 0, 10, 0 }, 785 { 1, 1, 0, 0 }, 786 787 { 1, 1, 0, 0 }, /* DBCC doesn't come BYTE. */ 788 { 32767, -32768, 2, TAB (DBCCABSJ, LONG) }, 789 { 0, 0, 10, 0 }, 790 { 1, 1, 0, 0 }, 791 792 { 1, 1, 0, 0 }, /* PCREL1632 doesn't come BYTE. */ 793 { 32767, -32768, 2, TAB (PCREL1632, LONG) }, 794 { 0, 0, 6, 0 }, 795 { 1, 1, 0, 0 }, 796 797 { 125, -130, 0, TAB (PCINDEX, SHORT) }, 798 { 32765, -32770, 2, TAB (PCINDEX, LONG) }, 799 { 0, 0, 4, 0 }, 800 { 1, 1, 0, 0 }, 801 802 { 1, 1, 0, 0 }, /* ABSTOPCREL doesn't come BYTE. */ 803 { 32767, -32768, 2, TAB (ABSTOPCREL, LONG) }, 804 { 0, 0, 4, 0 }, 805 { 1, 1, 0, 0 }, 806 807 { 127, -128, 0, TAB (BRANCHBWPL, SHORT) }, 808 { 32767, -32768, 2, TAB (BRANCHBWPL, LONG) }, 809 { 0, 0, 10, 0 }, 810 { 1, 1, 0, 0 }, 811 }; 812 813 /* These are the machine dependent pseudo-ops. These are included so 814 the assembler can work on the output from the SUN C compiler, which 815 generates these. */ 816 817 /* This table describes all the machine specific pseudo-ops the assembler 818 has to support. The fields are: 819 pseudo-op name without dot 820 function to call to execute this pseudo-op 821 Integer arg to pass to the function. */ 822 const pseudo_typeS md_pseudo_table[] = 823 { 824 {"data1", s_data1, 0}, 825 {"data2", s_data2, 0}, 826 {"bss", s_bss, 0}, 827 {"even", s_even, 0}, 828 {"skip", s_space, 0}, 829 {"proc", s_proc, 0}, 830 #if defined (TE_SUN3) || defined (OBJ_ELF) 831 {"align", s_align_bytes, 0}, 832 #endif 833 #ifdef OBJ_ELF 834 {"swbeg", s_ignore, 0}, 835 #endif 836 {"extend", float_cons, 'x'}, 837 {"ldouble", float_cons, 'x'}, 838 839 {"arch", s_m68k_arch, 0}, 840 {"cpu", s_m68k_cpu, 0}, 841 842 /* The following pseudo-ops are supported for MRI compatibility. */ 843 {"chip", s_chip, 0}, 844 {"comline", s_space, 1}, 845 {"fopt", s_fopt, 0}, 846 {"mask2", s_ignore, 0}, 847 {"opt", s_opt, 0}, 848 {"reg", s_reg, 0}, 849 {"restore", s_restore, 0}, 850 {"save", s_save, 0}, 851 852 {"if", s_mri_if, 0}, 853 {"if.b", s_mri_if, 'b'}, 854 {"if.w", s_mri_if, 'w'}, 855 {"if.l", s_mri_if, 'l'}, 856 {"else", s_mri_else, 0}, 857 {"else.s", s_mri_else, 's'}, 858 {"else.l", s_mri_else, 'l'}, 859 {"endi", s_mri_endi, 0}, 860 {"break", s_mri_break, 0}, 861 {"break.s", s_mri_break, 's'}, 862 {"break.l", s_mri_break, 'l'}, 863 {"next", s_mri_next, 0}, 864 {"next.s", s_mri_next, 's'}, 865 {"next.l", s_mri_next, 'l'}, 866 {"for", s_mri_for, 0}, 867 {"for.b", s_mri_for, 'b'}, 868 {"for.w", s_mri_for, 'w'}, 869 {"for.l", s_mri_for, 'l'}, 870 {"endf", s_mri_endf, 0}, 871 {"repeat", s_mri_repeat, 0}, 872 {"until", s_mri_until, 0}, 873 {"until.b", s_mri_until, 'b'}, 874 {"until.w", s_mri_until, 'w'}, 875 {"until.l", s_mri_until, 'l'}, 876 {"while", s_mri_while, 0}, 877 {"while.b", s_mri_while, 'b'}, 878 {"while.w", s_mri_while, 'w'}, 879 {"while.l", s_mri_while, 'l'}, 880 {"endw", s_mri_endw, 0}, 881 882 {0, 0, 0} 883 }; 884 885 /* The mote pseudo ops are put into the opcode table, since they 886 don't start with a . they look like opcodes to gas. */ 887 888 const pseudo_typeS mote_pseudo_table[] = 889 { 890 891 {"dcl", cons, 4}, 892 {"dc", cons, 2}, 893 {"dcw", cons, 2}, 894 {"dcb", cons, 1}, 895 896 {"dsl", s_space, 4}, 897 {"ds", s_space, 2}, 898 {"dsw", s_space, 2}, 899 {"dsb", s_space, 1}, 900 901 {"xdef", s_globl, 0}, 902 #ifdef OBJ_ELF 903 {"align", s_align_bytes, 0}, 904 #else 905 {"align", s_align_ptwo, 0}, 906 #endif 907 #ifdef M68KCOFF 908 {"sect", obj_coff_section, 0}, 909 {"section", obj_coff_section, 0}, 910 #endif 911 {0, 0, 0} 912 }; 913 914 /* Truncate and sign-extend at 32 bits, so that building on a 64-bit host 915 gives identical results to a 32-bit host. */ 916 #define TRUNC(X) ((valueT) (X) & 0xffffffff) 917 #define SEXT(X) ((TRUNC (X) ^ 0x80000000) - 0x80000000) 918 919 #define issbyte(x) ((valueT) SEXT (x) + 0x80 < 0x100) 920 #define isubyte(x) ((valueT) TRUNC (x) < 0x100) 921 #define issword(x) ((valueT) SEXT (x) + 0x8000 < 0x10000) 922 #define isuword(x) ((valueT) TRUNC (x) < 0x10000) 923 924 #define isbyte(x) ((valueT) SEXT (x) + 0xff < 0x1ff) 925 #define isword(x) ((valueT) SEXT (x) + 0xffff < 0x1ffff) 926 #define islong(x) (1) 927 928 static char notend_table[256]; 929 static char alt_notend_table[256]; 930 #define notend(s) \ 931 (! (notend_table[(unsigned char) *s] \ 932 || (*s == ':' \ 933 && alt_notend_table[(unsigned char) s[1]]))) 934 935 #ifdef OBJ_ELF 936 937 /* Return zero if the reference to SYMBOL from within the same segment may 938 be relaxed. */ 939 940 /* On an ELF system, we can't relax an externally visible symbol, 941 because it may be overridden by a shared library. However, if 942 TARGET_OS is "elf", then we presume that we are assembling for an 943 embedded system, in which case we don't have to worry about shared 944 libraries, and we can relax any external sym. */ 945 946 #define relaxable_symbol(symbol) \ 947 (!((S_IS_EXTERNAL (symbol) && EXTERN_FORCE_RELOC) \ 948 || S_IS_WEAK (symbol))) 949 950 /* Compute the relocation code for a fixup of SIZE bytes, using pc 951 relative relocation if PCREL is non-zero. PIC says whether a special 952 pic relocation was requested. */ 953 954 static bfd_reloc_code_real_type 955 get_reloc_code (int size, int pcrel, enum pic_relocation pic) 956 { 957 switch (pic) 958 { 959 case pic_got_pcrel: 960 switch (size) 961 { 962 case 1: 963 return BFD_RELOC_8_GOT_PCREL; 964 case 2: 965 return BFD_RELOC_16_GOT_PCREL; 966 case 4: 967 return BFD_RELOC_32_GOT_PCREL; 968 } 969 break; 970 971 case pic_got_off: 972 switch (size) 973 { 974 case 1: 975 return BFD_RELOC_8_GOTOFF; 976 case 2: 977 return BFD_RELOC_16_GOTOFF; 978 case 4: 979 return BFD_RELOC_32_GOTOFF; 980 } 981 break; 982 983 case pic_plt_pcrel: 984 switch (size) 985 { 986 case 1: 987 return BFD_RELOC_8_PLT_PCREL; 988 case 2: 989 return BFD_RELOC_16_PLT_PCREL; 990 case 4: 991 return BFD_RELOC_32_PLT_PCREL; 992 } 993 break; 994 995 case pic_plt_off: 996 switch (size) 997 { 998 case 1: 999 return BFD_RELOC_8_PLTOFF; 1000 case 2: 1001 return BFD_RELOC_16_PLTOFF; 1002 case 4: 1003 return BFD_RELOC_32_PLTOFF; 1004 } 1005 break; 1006 1007 case pic_none: 1008 if (pcrel) 1009 { 1010 switch (size) 1011 { 1012 case 1: 1013 return BFD_RELOC_8_PCREL; 1014 case 2: 1015 return BFD_RELOC_16_PCREL; 1016 case 4: 1017 return BFD_RELOC_32_PCREL; 1018 } 1019 } 1020 else 1021 { 1022 switch (size) 1023 { 1024 case 1: 1025 return BFD_RELOC_8; 1026 case 2: 1027 return BFD_RELOC_16; 1028 case 4: 1029 return BFD_RELOC_32; 1030 } 1031 } 1032 } 1033 1034 if (pcrel) 1035 { 1036 if (pic == pic_none) 1037 as_bad (_("Can not do %d byte pc-relative relocation"), size); 1038 else 1039 as_bad (_("Can not do %d byte pc-relative pic relocation"), size); 1040 } 1041 else 1042 { 1043 if (pic == pic_none) 1044 as_bad (_("Can not do %d byte relocation"), size); 1045 else 1046 as_bad (_("Can not do %d byte pic relocation"), size); 1047 } 1048 1049 return BFD_RELOC_NONE; 1050 } 1051 1052 /* Here we decide which fixups can be adjusted to make them relative 1053 to the beginning of the section instead of the symbol. Basically 1054 we need to make sure that the dynamic relocations are done 1055 correctly, so in some cases we force the original symbol to be 1056 used. */ 1057 int 1058 tc_m68k_fix_adjustable (fixS *fixP) 1059 { 1060 /* Adjust_reloc_syms doesn't know about the GOT. */ 1061 switch (fixP->fx_r_type) 1062 { 1063 case BFD_RELOC_8_GOT_PCREL: 1064 case BFD_RELOC_16_GOT_PCREL: 1065 case BFD_RELOC_32_GOT_PCREL: 1066 case BFD_RELOC_8_GOTOFF: 1067 case BFD_RELOC_16_GOTOFF: 1068 case BFD_RELOC_32_GOTOFF: 1069 case BFD_RELOC_8_PLT_PCREL: 1070 case BFD_RELOC_16_PLT_PCREL: 1071 case BFD_RELOC_32_PLT_PCREL: 1072 case BFD_RELOC_8_PLTOFF: 1073 case BFD_RELOC_16_PLTOFF: 1074 case BFD_RELOC_32_PLTOFF: 1075 return 0; 1076 1077 case BFD_RELOC_VTABLE_INHERIT: 1078 case BFD_RELOC_VTABLE_ENTRY: 1079 return 0; 1080 1081 default: 1082 return 1; 1083 } 1084 } 1085 1086 #else /* !OBJ_ELF */ 1087 1088 #define get_reloc_code(SIZE,PCREL,OTHER) NO_RELOC 1089 1090 /* PR gas/3041 Weak symbols are not relaxable 1091 because they must be treated as extern. */ 1092 #define relaxable_symbol(symbol) (!(S_IS_WEAK (symbol))) 1093 1094 #endif /* OBJ_ELF */ 1095 1096 arelent * 1097 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp) 1098 { 1099 arelent *reloc; 1100 bfd_reloc_code_real_type code; 1101 1102 /* If the tcbit is set, then this was a fixup of a negative value 1103 that was never resolved. We do not have a reloc to handle this, 1104 so just return. We assume that other code will have detected this 1105 situation and produced a helpful error message, so we just tell the 1106 user that the reloc cannot be produced. */ 1107 if (fixp->fx_tcbit) 1108 { 1109 if (fixp->fx_addsy) 1110 as_bad_where (fixp->fx_file, fixp->fx_line, 1111 _("Unable to produce reloc against symbol '%s'"), 1112 S_GET_NAME (fixp->fx_addsy)); 1113 return NULL; 1114 } 1115 1116 if (fixp->fx_r_type != BFD_RELOC_NONE) 1117 { 1118 code = fixp->fx_r_type; 1119 1120 /* Since DIFF_EXPR_OK is defined in tc-m68k.h, it is possible 1121 that fixup_segment converted a non-PC relative reloc into a 1122 PC relative reloc. In such a case, we need to convert the 1123 reloc code. */ 1124 if (fixp->fx_pcrel) 1125 { 1126 switch (code) 1127 { 1128 case BFD_RELOC_8: 1129 code = BFD_RELOC_8_PCREL; 1130 break; 1131 case BFD_RELOC_16: 1132 code = BFD_RELOC_16_PCREL; 1133 break; 1134 case BFD_RELOC_32: 1135 code = BFD_RELOC_32_PCREL; 1136 break; 1137 case BFD_RELOC_8_PCREL: 1138 case BFD_RELOC_16_PCREL: 1139 case BFD_RELOC_32_PCREL: 1140 case BFD_RELOC_8_GOT_PCREL: 1141 case BFD_RELOC_16_GOT_PCREL: 1142 case BFD_RELOC_32_GOT_PCREL: 1143 case BFD_RELOC_8_GOTOFF: 1144 case BFD_RELOC_16_GOTOFF: 1145 case BFD_RELOC_32_GOTOFF: 1146 case BFD_RELOC_8_PLT_PCREL: 1147 case BFD_RELOC_16_PLT_PCREL: 1148 case BFD_RELOC_32_PLT_PCREL: 1149 case BFD_RELOC_8_PLTOFF: 1150 case BFD_RELOC_16_PLTOFF: 1151 case BFD_RELOC_32_PLTOFF: 1152 break; 1153 default: 1154 as_bad_where (fixp->fx_file, fixp->fx_line, 1155 _("Cannot make %s relocation PC relative"), 1156 bfd_get_reloc_code_name (code)); 1157 } 1158 } 1159 } 1160 else 1161 { 1162 #define F(SZ,PCREL) (((SZ) << 1) + (PCREL)) 1163 switch (F (fixp->fx_size, fixp->fx_pcrel)) 1164 { 1165 #define MAP(SZ,PCREL,TYPE) case F(SZ,PCREL): code = (TYPE); break 1166 MAP (1, 0, BFD_RELOC_8); 1167 MAP (2, 0, BFD_RELOC_16); 1168 MAP (4, 0, BFD_RELOC_32); 1169 MAP (1, 1, BFD_RELOC_8_PCREL); 1170 MAP (2, 1, BFD_RELOC_16_PCREL); 1171 MAP (4, 1, BFD_RELOC_32_PCREL); 1172 default: 1173 abort (); 1174 } 1175 } 1176 #undef F 1177 #undef MAP 1178 1179 reloc = (arelent *) xmalloc (sizeof (arelent)); 1180 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); 1181 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy); 1182 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where; 1183 #ifndef OBJ_ELF 1184 if (fixp->fx_pcrel) 1185 reloc->addend = fixp->fx_addnumber; 1186 else if (OUTPUT_FLAVOR == bfd_target_aout_flavour 1187 && fixp->fx_addsy 1188 && S_IS_WEAK (fixp->fx_addsy) 1189 && ! bfd_is_und_section (S_GET_SEGMENT (fixp->fx_addsy))) 1190 /* PR gas/3041 Adjust addend in order to force bfd_install_relocation() 1191 to put the symbol offset into frags referencing a weak symbol. */ 1192 reloc->addend = fixp->fx_addnumber 1193 - (S_GET_VALUE (fixp->fx_addsy) * 2); 1194 else 1195 reloc->addend = 0; 1196 #else 1197 if (!fixp->fx_pcrel) 1198 reloc->addend = fixp->fx_addnumber; 1199 else 1200 reloc->addend = (section->vma 1201 /* Explicit sign extension in case char is 1202 unsigned. */ 1203 + ((fixp->fx_pcrel_adjust & 0xff) ^ 0x80) - 0x80 1204 + fixp->fx_addnumber 1205 + md_pcrel_from (fixp)); 1206 #endif 1207 1208 reloc->howto = bfd_reloc_type_lookup (stdoutput, code); 1209 assert (reloc->howto != 0); 1210 1211 return reloc; 1212 } 1213 1214 /* Handle of the OPCODE hash table. NULL means any use before 1215 m68k_ip_begin() will crash. */ 1216 static struct hash_control *op_hash; 1217 1218 /* Assemble an m68k instruction. */ 1219 1220 static void 1221 m68k_ip (char *instring) 1222 { 1223 register char *p; 1224 register struct m68k_op *opP; 1225 register const struct m68k_incant *opcode; 1226 register const char *s; 1227 register int tmpreg = 0, baseo = 0, outro = 0, nextword; 1228 char *pdot, *pdotmove; 1229 enum m68k_size siz1, siz2; 1230 char c; 1231 int losing; 1232 int opsfound; 1233 struct m68k_op operands_backup[6]; 1234 LITTLENUM_TYPE words[6]; 1235 LITTLENUM_TYPE *wordp; 1236 unsigned long ok_arch = 0; 1237 1238 if (*instring == ' ') 1239 instring++; /* Skip leading whitespace. */ 1240 1241 /* Scan up to end of operation-code, which MUST end in end-of-string 1242 or exactly 1 space. */ 1243 pdot = 0; 1244 for (p = instring; *p != '\0'; p++) 1245 { 1246 if (*p == ' ') 1247 break; 1248 if (*p == '.') 1249 pdot = p; 1250 } 1251 1252 if (p == instring) 1253 { 1254 the_ins.error = _("No operator"); 1255 return; 1256 } 1257 1258 /* p now points to the end of the opcode name, probably whitespace. 1259 Make sure the name is null terminated by clobbering the 1260 whitespace, look it up in the hash table, then fix it back. 1261 Remove a dot, first, since the opcode tables have none. */ 1262 if (pdot != NULL) 1263 { 1264 for (pdotmove = pdot; pdotmove < p; pdotmove++) 1265 *pdotmove = pdotmove[1]; 1266 p--; 1267 } 1268 1269 c = *p; 1270 *p = '\0'; 1271 opcode = (const struct m68k_incant *) hash_find (op_hash, instring); 1272 *p = c; 1273 1274 if (pdot != NULL) 1275 { 1276 for (pdotmove = p; pdotmove > pdot; pdotmove--) 1277 *pdotmove = pdotmove[-1]; 1278 *pdot = '.'; 1279 ++p; 1280 } 1281 1282 if (opcode == NULL) 1283 { 1284 the_ins.error = _("Unknown operator"); 1285 return; 1286 } 1287 1288 /* Found a legitimate opcode, start matching operands. */ 1289 while (*p == ' ') 1290 ++p; 1291 1292 if (opcode->m_operands == 0) 1293 { 1294 char *old = input_line_pointer; 1295 *old = '\n'; 1296 input_line_pointer = p; 1297 /* Ahh - it's a motorola style psuedo op. */ 1298 mote_pseudo_table[opcode->m_opnum].poc_handler 1299 (mote_pseudo_table[opcode->m_opnum].poc_val); 1300 input_line_pointer = old; 1301 *old = 0; 1302 1303 return; 1304 } 1305 1306 if (flag_mri && opcode->m_opnum == 0) 1307 { 1308 /* In MRI mode, random garbage is allowed after an instruction 1309 which accepts no operands. */ 1310 the_ins.args = opcode->m_operands; 1311 the_ins.numargs = opcode->m_opnum; 1312 the_ins.numo = opcode->m_codenum; 1313 the_ins.opcode[0] = getone (opcode); 1314 the_ins.opcode[1] = gettwo (opcode); 1315 return; 1316 } 1317 1318 for (opP = &the_ins.operands[0]; *p; opP++) 1319 { 1320 p = crack_operand (p, opP); 1321 1322 if (opP->error) 1323 { 1324 the_ins.error = opP->error; 1325 return; 1326 } 1327 } 1328 1329 opsfound = opP - &the_ins.operands[0]; 1330 1331 /* This ugly hack is to support the floating pt opcodes in their 1332 standard form. Essentially, we fake a first enty of type COP#1 */ 1333 if (opcode->m_operands[0] == 'I') 1334 { 1335 int n; 1336 1337 for (n = opsfound; n > 0; --n) 1338 the_ins.operands[n] = the_ins.operands[n - 1]; 1339 1340 memset (&the_ins.operands[0], '\0', sizeof (the_ins.operands[0])); 1341 the_ins.operands[0].mode = CONTROL; 1342 the_ins.operands[0].reg = m68k_float_copnum; 1343 opsfound++; 1344 } 1345 1346 /* We've got the operands. Find an opcode that'll accept them. */ 1347 for (losing = 0;;) 1348 { 1349 /* If we didn't get the right number of ops, or we have no 1350 common model with this pattern then reject this pattern. */ 1351 1352 ok_arch |= opcode->m_arch; 1353 if (opsfound != opcode->m_opnum 1354 || ((opcode->m_arch & current_architecture) == 0)) 1355 ++losing; 1356 else 1357 { 1358 int i; 1359 1360 /* Make a copy of the operands of this insn so that 1361 we can modify them safely, should we want to. */ 1362 assert (opsfound <= (int) ARRAY_SIZE (operands_backup)); 1363 for (i = 0; i < opsfound; i++) 1364 operands_backup[i] = the_ins.operands[i]; 1365 1366 for (s = opcode->m_operands, opP = &operands_backup[0]; 1367 *s && !losing; 1368 s += 2, opP++) 1369 { 1370 /* Warning: this switch is huge! */ 1371 /* I've tried to organize the cases into this order: 1372 non-alpha first, then alpha by letter. Lower-case 1373 goes directly before uppercase counterpart. */ 1374 /* Code with multiple case ...: gets sorted by the lowest 1375 case ... it belongs to. I hope this makes sense. */ 1376 switch (*s) 1377 { 1378 case '!': 1379 switch (opP->mode) 1380 { 1381 case IMMED: 1382 case DREG: 1383 case AREG: 1384 case FPREG: 1385 case CONTROL: 1386 case AINC: 1387 case ADEC: 1388 case REGLST: 1389 losing++; 1390 break; 1391 default: 1392 break; 1393 } 1394 break; 1395 1396 case '<': 1397 switch (opP->mode) 1398 { 1399 case DREG: 1400 case AREG: 1401 case FPREG: 1402 case CONTROL: 1403 case IMMED: 1404 case ADEC: 1405 case REGLST: 1406 losing++; 1407 break; 1408 default: 1409 break; 1410 } 1411 break; 1412 1413 case '>': 1414 switch (opP->mode) 1415 { 1416 case DREG: 1417 case AREG: 1418 case FPREG: 1419 case CONTROL: 1420 case IMMED: 1421 case AINC: 1422 case REGLST: 1423 losing++; 1424 break; 1425 case ABSL: 1426 break; 1427 default: 1428 if (opP->reg == PC 1429 || opP->reg == ZPC) 1430 losing++; 1431 break; 1432 } 1433 break; 1434 1435 case 'm': 1436 switch (opP->mode) 1437 { 1438 case DREG: 1439 case AREG: 1440 case AINDR: 1441 case AINC: 1442 case ADEC: 1443 break; 1444 default: 1445 losing++; 1446 } 1447 break; 1448 1449 case 'n': 1450 switch (opP->mode) 1451 { 1452 case DISP: 1453 break; 1454 default: 1455 losing++; 1456 } 1457 break; 1458 1459 case 'o': 1460 switch (opP->mode) 1461 { 1462 case BASE: 1463 case ABSL: 1464 case IMMED: 1465 break; 1466 default: 1467 losing++; 1468 } 1469 break; 1470 1471 case 'p': 1472 switch (opP->mode) 1473 { 1474 case DREG: 1475 case AREG: 1476 case AINDR: 1477 case AINC: 1478 case ADEC: 1479 break; 1480 case DISP: 1481 if (opP->reg == PC || opP->reg == ZPC) 1482 losing++; 1483 break; 1484 default: 1485 losing++; 1486 } 1487 break; 1488 1489 case 'q': 1490 switch (opP->mode) 1491 { 1492 case DREG: 1493 case AINDR: 1494 case AINC: 1495 case ADEC: 1496 break; 1497 case DISP: 1498 if (opP->reg == PC || opP->reg == ZPC) 1499 losing++; 1500 break; 1501 default: 1502 losing++; 1503 break; 1504 } 1505 break; 1506 1507 case 'v': 1508 switch (opP->mode) 1509 { 1510 case DREG: 1511 case AINDR: 1512 case AINC: 1513 case ADEC: 1514 case ABSL: 1515 break; 1516 case DISP: 1517 if (opP->reg == PC || opP->reg == ZPC) 1518 losing++; 1519 break; 1520 default: 1521 losing++; 1522 break; 1523 } 1524 break; 1525 1526 case '#': 1527 if (opP->mode != IMMED) 1528 losing++; 1529 else if (s[1] == 'b' 1530 && ! isvar (&opP->disp) 1531 && (opP->disp.exp.X_op != O_constant 1532 || ! isbyte (opP->disp.exp.X_add_number))) 1533 losing++; 1534 else if (s[1] == 'B' 1535 && ! isvar (&opP->disp) 1536 && (opP->disp.exp.X_op != O_constant 1537 || ! issbyte (opP->disp.exp.X_add_number))) 1538 losing++; 1539 else if (s[1] == 'w' 1540 && ! isvar (&opP->disp) 1541 && (opP->disp.exp.X_op != O_constant 1542 || ! isword (opP->disp.exp.X_add_number))) 1543 losing++; 1544 else if (s[1] == 'W' 1545 && ! isvar (&opP->disp) 1546 && (opP->disp.exp.X_op != O_constant 1547 || ! issword (opP->disp.exp.X_add_number))) 1548 losing++; 1549 break; 1550 1551 case '^': 1552 case 'T': 1553 if (opP->mode != IMMED) 1554 losing++; 1555 break; 1556 1557 case '$': 1558 if (opP->mode == AREG 1559 || opP->mode == CONTROL 1560 || opP->mode == FPREG 1561 || opP->mode == IMMED 1562 || opP->mode == REGLST 1563 || (opP->mode != ABSL 1564 && (opP->reg == PC 1565 || opP->reg == ZPC))) 1566 losing++; 1567 break; 1568 1569 case '%': 1570 if (opP->mode == CONTROL 1571 || opP->mode == FPREG 1572 || opP->mode == REGLST 1573 || opP->mode == IMMED 1574 || (opP->mode != ABSL 1575 && (opP->reg == PC 1576 || opP->reg == ZPC))) 1577 losing++; 1578 break; 1579 1580 case '&': 1581 switch (opP->mode) 1582 { 1583 case DREG: 1584 case AREG: 1585 case FPREG: 1586 case CONTROL: 1587 case IMMED: 1588 case AINC: 1589 case ADEC: 1590 case REGLST: 1591 losing++; 1592 break; 1593 case ABSL: 1594 break; 1595 default: 1596 if (opP->reg == PC 1597 || opP->reg == ZPC) 1598 losing++; 1599 break; 1600 } 1601 break; 1602 1603 case '*': 1604 if (opP->mode == CONTROL 1605 || opP->mode == FPREG 1606 || opP->mode == REGLST) 1607 losing++; 1608 break; 1609 1610 case '+': 1611 if (opP->mode != AINC) 1612 losing++; 1613 break; 1614 1615 case '-': 1616 if (opP->mode != ADEC) 1617 losing++; 1618 break; 1619 1620 case '/': 1621 switch (opP->mode) 1622 { 1623 case AREG: 1624 case CONTROL: 1625 case FPREG: 1626 case AINC: 1627 case ADEC: 1628 case IMMED: 1629 case REGLST: 1630 losing++; 1631 break; 1632 default: 1633 break; 1634 } 1635 break; 1636 1637 case ';': 1638 switch (opP->mode) 1639 { 1640 case AREG: 1641 case CONTROL: 1642 case FPREG: 1643 case REGLST: 1644 losing++; 1645 break; 1646 default: 1647 break; 1648 } 1649 break; 1650 1651 case '?': 1652 switch (opP->mode) 1653 { 1654 case AREG: 1655 case CONTROL: 1656 case FPREG: 1657 case AINC: 1658 case ADEC: 1659 case IMMED: 1660 case REGLST: 1661 losing++; 1662 break; 1663 case ABSL: 1664 break; 1665 default: 1666 if (opP->reg == PC || opP->reg == ZPC) 1667 losing++; 1668 break; 1669 } 1670 break; 1671 1672 case '@': 1673 switch (opP->mode) 1674 { 1675 case AREG: 1676 case CONTROL: 1677 case FPREG: 1678 case IMMED: 1679 case REGLST: 1680 losing++; 1681 break; 1682 default: 1683 break; 1684 } 1685 break; 1686 1687 case '~': /* For now! (JF FOO is this right?) */ 1688 switch (opP->mode) 1689 { 1690 case DREG: 1691 case AREG: 1692 case CONTROL: 1693 case FPREG: 1694 case IMMED: 1695 case REGLST: 1696 losing++; 1697 break; 1698 case ABSL: 1699 break; 1700 default: 1701 if (opP->reg == PC 1702 || opP->reg == ZPC) 1703 losing++; 1704 break; 1705 } 1706 break; 1707 1708 case '3': 1709 if (opP->mode != CONTROL 1710 || (opP->reg != TT0 && opP->reg != TT1)) 1711 losing++; 1712 break; 1713 1714 case 'A': 1715 if (opP->mode != AREG) 1716 losing++; 1717 break; 1718 1719 case 'a': 1720 if (opP->mode != AINDR) 1721 ++losing; 1722 break; 1723 1724 case '4': 1725 if (opP->mode != AINDR && opP->mode != AINC && opP->mode != ADEC 1726 && (opP->mode != DISP 1727 || opP->reg < ADDR0 1728 || opP->reg > ADDR7)) 1729 ++losing; 1730 break; 1731 1732 case 'B': /* FOO */ 1733 if (opP->mode != ABSL 1734 || (flag_long_jumps 1735 && strncmp (instring, "jbsr", 4) == 0)) 1736 losing++; 1737 break; 1738 1739 case 'b': 1740 switch (opP->mode) 1741 { 1742 case IMMED: 1743 case ABSL: 1744 case AREG: 1745 case FPREG: 1746 case CONTROL: 1747 case POST: 1748 case PRE: 1749 case REGLST: 1750 losing++; 1751 break; 1752 default: 1753 break; 1754 } 1755 break; 1756 1757 case 'C': 1758 if (opP->mode != CONTROL || opP->reg != CCR) 1759 losing++; 1760 break; 1761 1762 case 'd': 1763 if (opP->mode != DISP 1764 || opP->reg < ADDR0 1765 || opP->reg > ADDR7) 1766 losing++; 1767 break; 1768 1769 case 'D': 1770 if (opP->mode != DREG) 1771 losing++; 1772 break; 1773 1774 case 'E': 1775 if (opP->reg != ACC) 1776 losing++; 1777 break; 1778 1779 case 'e': 1780 if (opP->reg != ACC && opP->reg != ACC1 1781 && opP->reg != ACC2 && opP->reg != ACC3) 1782 losing++; 1783 break; 1784 1785 case 'F': 1786 if (opP->mode != FPREG) 1787 losing++; 1788 break; 1789 1790 case 'G': 1791 if (opP->reg != MACSR) 1792 losing++; 1793 break; 1794 1795 case 'g': 1796 if (opP->reg != ACCEXT01 && opP->reg != ACCEXT23) 1797 losing++; 1798 break; 1799 1800 case 'H': 1801 if (opP->reg != MASK) 1802 losing++; 1803 break; 1804 1805 case 'I': 1806 if (opP->mode != CONTROL 1807 || opP->reg < COP0 1808 || opP->reg > COP7) 1809 losing++; 1810 break; 1811 1812 case 'i': 1813 if (opP->mode != LSH && opP->mode != RSH) 1814 losing++; 1815 break; 1816 1817 case 'J': 1818 if (opP->mode != CONTROL 1819 || opP->reg < USP 1820 || opP->reg > last_movec_reg 1821 || !control_regs) 1822 losing++; 1823 else 1824 { 1825 const enum m68k_register *rp; 1826 1827 for (rp = control_regs; *rp; rp++) 1828 { 1829 if (*rp == opP->reg) 1830 break; 1831 /* In most CPUs RAMBAR refers to control reg 1832 c05 (RAMBAR1), but a few CPUs have it 1833 refer to c04 (RAMBAR0). */ 1834 else if (*rp == RAMBAR_ALT && opP->reg == RAMBAR) 1835 { 1836 opP->reg = RAMBAR_ALT; 1837 break; 1838 } 1839 } 1840 if (*rp == 0) 1841 losing++; 1842 } 1843 break; 1844 1845 case 'k': 1846 if (opP->mode != IMMED) 1847 losing++; 1848 break; 1849 1850 case 'l': 1851 case 'L': 1852 if (opP->mode == DREG 1853 || opP->mode == AREG 1854 || opP->mode == FPREG) 1855 { 1856 if (s[1] == '8') 1857 losing++; 1858 else 1859 { 1860 switch (opP->mode) 1861 { 1862 case DREG: 1863 opP->mask = 1 << (opP->reg - DATA0); 1864 break; 1865 case AREG: 1866 opP->mask = 1 << (opP->reg - ADDR0 + 8); 1867 break; 1868 case FPREG: 1869 opP->mask = 1 << (opP->reg - FP0 + 16); 1870 break; 1871 default: 1872 abort (); 1873 } 1874 opP->mode = REGLST; 1875 } 1876 } 1877 else if (opP->mode == CONTROL) 1878 { 1879 if (s[1] != '8') 1880 losing++; 1881 else 1882 { 1883 switch (opP->reg) 1884 { 1885 case FPI: 1886 opP->mask = 1 << 24; 1887 break; 1888 case FPS: 1889 opP->mask = 1 << 25; 1890 break; 1891 case FPC: 1892 opP->mask = 1 << 26; 1893 break; 1894 default: 1895 losing++; 1896 break; 1897 } 1898 opP->mode = REGLST; 1899 } 1900 } 1901 else if (opP->mode != REGLST) 1902 losing++; 1903 else if (s[1] == '8' && (opP->mask & 0x0ffffff) != 0) 1904 losing++; 1905 else if (s[1] == '3' && (opP->mask & 0x7000000) != 0) 1906 losing++; 1907 break; 1908 1909 case 'M': 1910 if (opP->mode != IMMED) 1911 losing++; 1912 else if (opP->disp.exp.X_op != O_constant 1913 || ! issbyte (opP->disp.exp.X_add_number)) 1914 losing++; 1915 else if (! m68k_quick 1916 && instring[3] != 'q' 1917 && instring[4] != 'q') 1918 losing++; 1919 break; 1920 1921 case 'O': 1922 if (opP->mode != DREG 1923 && opP->mode != IMMED 1924 && opP->mode != ABSL) 1925 losing++; 1926 break; 1927 1928 case 'Q': 1929 if (opP->mode != IMMED) 1930 losing++; 1931 else if (opP->disp.exp.X_op != O_constant 1932 || TRUNC (opP->disp.exp.X_add_number) - 1 > 7) 1933 losing++; 1934 else if (! m68k_quick 1935 && (strncmp (instring, "add", 3) == 0 1936 || strncmp (instring, "sub", 3) == 0) 1937 && instring[3] != 'q') 1938 losing++; 1939 break; 1940 1941 case 'R': 1942 if (opP->mode != DREG && opP->mode != AREG) 1943 losing++; 1944 break; 1945 1946 case 'r': 1947 if (opP->mode != AINDR 1948 && (opP->mode != BASE 1949 || (opP->reg != 0 1950 && opP->reg != ZADDR0) 1951 || opP->disp.exp.X_op != O_absent 1952 || ((opP->index.reg < DATA0 1953 || opP->index.reg > DATA7) 1954 && (opP->index.reg < ADDR0 1955 || opP->index.reg > ADDR7)) 1956 || opP->index.size != SIZE_UNSPEC 1957 || opP->index.scale != 1)) 1958 losing++; 1959 break; 1960 1961 case 's': 1962 if (opP->mode != CONTROL 1963 || ! (opP->reg == FPI 1964 || opP->reg == FPS 1965 || opP->reg == FPC)) 1966 losing++; 1967 break; 1968 1969 case 'S': 1970 if (opP->mode != CONTROL || opP->reg != SR) 1971 losing++; 1972 break; 1973 1974 case 't': 1975 if (opP->mode != IMMED) 1976 losing++; 1977 else if (opP->disp.exp.X_op != O_constant 1978 || TRUNC (opP->disp.exp.X_add_number) > 7) 1979 losing++; 1980 break; 1981 1982 case 'U': 1983 if (opP->mode != CONTROL || opP->reg != USP) 1984 losing++; 1985 break; 1986 1987 case 'x': 1988 if (opP->mode != IMMED) 1989 losing++; 1990 else if (opP->disp.exp.X_op != O_constant 1991 || (TRUNC (opP->disp.exp.X_add_number) != 0xffffffff 1992 && TRUNC (opP->disp.exp.X_add_number) - 1 > 6)) 1993 losing++; 1994 break; 1995 1996 case 'j': 1997 if (opP->mode != IMMED) 1998 losing++; 1999 else if (opP->disp.exp.X_op != O_constant 2000 || TRUNC (opP->disp.exp.X_add_number) - 1 > 7) 2001 losing++; 2002 break; 2003 2004 case 'K': 2005 if (opP->mode != IMMED) 2006 losing++; 2007 else if (opP->disp.exp.X_op != O_constant 2008 || TRUNC (opP->disp.exp.X_add_number) > 511) 2009 losing++; 2010 break; 2011 2012 /* JF these are out of order. We could put them 2013 in order if we were willing to put up with 2014 bunches of #ifdef m68851s in the code. 2015 2016 Don't forget that you need these operands 2017 to use 68030 MMU instructions. */ 2018 #ifndef NO_68851 2019 /* Memory addressing mode used by pflushr. */ 2020 case '|': 2021 if (opP->mode == CONTROL 2022 || opP->mode == FPREG 2023 || opP->mode == DREG 2024 || opP->mode == AREG 2025 || opP->mode == REGLST) 2026 losing++; 2027 /* We should accept immediate operands, but they 2028 supposedly have to be quad word, and we don't 2029 handle that. I would like to see what a Motorola 2030 assembler does before doing something here. */ 2031 if (opP->mode == IMMED) 2032 losing++; 2033 break; 2034 2035 case 'f': 2036 if (opP->mode != CONTROL 2037 || (opP->reg != SFC && opP->reg != DFC)) 2038 losing++; 2039 break; 2040 2041 case '0': 2042 if (opP->mode != CONTROL || opP->reg != TC) 2043 losing++; 2044 break; 2045 2046 case '1': 2047 if (opP->mode != CONTROL || opP->reg != AC) 2048 losing++; 2049 break; 2050 2051 case '2': 2052 if (opP->mode != CONTROL 2053 || (opP->reg != CAL 2054 && opP->reg != VAL 2055 && opP->reg != SCC)) 2056 losing++; 2057 break; 2058 2059 case 'V': 2060 if (opP->mode != CONTROL 2061 || opP->reg != VAL) 2062 losing++; 2063 break; 2064 2065 case 'W': 2066 if (opP->mode != CONTROL 2067 || (opP->reg != DRP 2068 && opP->reg != SRP 2069 && opP->reg != CRP)) 2070 losing++; 2071 break; 2072 2073 case 'w': 2074 switch (opP->mode) 2075 { 2076 case IMMED: 2077 case ABSL: 2078 case AREG: 2079 case DREG: 2080 case FPREG: 2081 case CONTROL: 2082 case POST: 2083 case PRE: 2084 case REGLST: 2085 losing++; 2086 break; 2087 default: 2088 break; 2089 } 2090 break; 2091 2092 case 'X': 2093 if (opP->mode != CONTROL 2094 || (!(opP->reg >= BAD && opP->reg <= BAD + 7) 2095 && !(opP->reg >= BAC && opP->reg <= BAC + 7))) 2096 losing++; 2097 break; 2098 2099 case 'Y': 2100 if (opP->mode != CONTROL || opP->reg != PSR) 2101 losing++; 2102 break; 2103 2104 case 'Z': 2105 if (opP->mode != CONTROL || opP->reg != PCSR) 2106 losing++; 2107 break; 2108 #endif 2109 case 'c': 2110 if (opP->mode != CONTROL 2111 || (opP->reg != NC 2112 && opP->reg != IC 2113 && opP->reg != DC 2114 && opP->reg != BC)) 2115 losing++; 2116 break; 2117 2118 case '_': 2119 if (opP->mode != ABSL) 2120 ++losing; 2121 break; 2122 2123 case 'u': 2124 if (opP->reg < DATA0L || opP->reg > ADDR7U) 2125 losing++; 2126 /* FIXME: kludge instead of fixing parser: 2127 upper/lower registers are *not* CONTROL 2128 registers, but ordinary ones. */ 2129 if ((opP->reg >= DATA0L && opP->reg <= DATA7L) 2130 || (opP->reg >= DATA0U && opP->reg <= DATA7U)) 2131 opP->mode = DREG; 2132 else 2133 opP->mode = AREG; 2134 break; 2135 2136 case 'y': 2137 if (!(opP->mode == AINDR 2138 || (opP->mode == DISP 2139 && !(opP->reg == PC || opP->reg == ZPC)))) 2140 losing++; 2141 break; 2142 2143 case 'z': 2144 if (!(opP->mode == AINDR || opP->mode == DISP)) 2145 losing++; 2146 break; 2147 2148 default: 2149 abort (); 2150 } 2151 2152 if (losing) 2153 break; 2154 } 2155 2156 /* Since we have found the correct instruction, copy 2157 in the modifications that we may have made. */ 2158 if (!losing) 2159 for (i = 0; i < opsfound; i++) 2160 the_ins.operands[i] = operands_backup[i]; 2161 } 2162 2163 if (!losing) 2164 break; 2165 2166 opcode = opcode->m_next; 2167 2168 if (!opcode) 2169 { 2170 if (ok_arch 2171 && !(ok_arch & current_architecture)) 2172 { 2173 const struct m68k_cpu *cpu; 2174 int any = 0; 2175 size_t space = 400; 2176 char *buf = xmalloc (space + 1); 2177 size_t len; 2178 int paren = 1; 2179 2180 the_ins.error = buf; 2181 /* Make sure there's a NUL at the end of the buffer -- strncpy 2182 won't write one when it runs out of buffer. */ 2183 buf[space] = 0; 2184 #define APPEND(STRING) \ 2185 (strncpy (buf, STRING, space), len = strlen (buf), buf += len, space -= len) 2186 2187 APPEND (_("invalid instruction for this architecture; needs ")); 2188 switch (ok_arch) 2189 { 2190 case mcfisa_a: 2191 APPEND ("ColdFire ISA_A"); 2192 break; 2193 case mcfhwdiv: 2194 APPEND ("ColdFire "); 2195 APPEND (_("hardware divide")); 2196 break; 2197 case mcfisa_aa: 2198 APPEND ("ColdFire ISA_A+"); 2199 break; 2200 case mcfisa_b: 2201 APPEND ("ColdFire ISA_B"); 2202 break; 2203 case mcfisa_c: 2204 APPEND ("ColdFire ISA_C"); 2205 break; 2206 case cfloat: 2207 APPEND ("ColdFire fpu"); 2208 break; 2209 case mfloat: 2210 APPEND ("M68K fpu"); 2211 break; 2212 case mmmu: 2213 APPEND ("M68K mmu"); 2214 break; 2215 case m68020up: 2216 APPEND ("68020 "); 2217 APPEND (_("or higher")); 2218 break; 2219 case m68000up: 2220 APPEND ("68000 "); 2221 APPEND (_("or higher")); 2222 break; 2223 case m68010up: 2224 APPEND ("68010 "); 2225 APPEND (_("or higher")); 2226 break; 2227 default: 2228 paren = 0; 2229 } 2230 if (paren) 2231 APPEND (" ("); 2232 2233 for (cpu = m68k_cpus; cpu->name; cpu++) 2234 if (!cpu->alias && (cpu->arch & ok_arch)) 2235 { 2236 const struct m68k_cpu *alias; 2237 int seen_master = 0; 2238 2239 if (any) 2240 APPEND (", "); 2241 any = 0; 2242 APPEND (cpu->name); 2243 for (alias = cpu; alias != m68k_cpus; alias--) 2244 if (alias[-1].alias >= 0) 2245 break; 2246 for (; !seen_master || alias->alias > 0; alias++) 2247 { 2248 if (!alias->alias) 2249 seen_master = 1; 2250 else 2251 { 2252 if (any) 2253 APPEND (", "); 2254 else 2255 APPEND (" ["); 2256 APPEND (alias->name); 2257 any = 1; 2258 } 2259 } 2260 if (any) 2261 APPEND ("]"); 2262 any = 1; 2263 } 2264 if (paren) 2265 APPEND (")"); 2266 #undef APPEND 2267 if (!space) 2268 { 2269 /* We ran out of space, so replace the end of the list 2270 with ellipsis. */ 2271 buf -= 4; 2272 while (*buf != ' ') 2273 buf--; 2274 strcpy (buf, " ..."); 2275 } 2276 } 2277 else 2278 the_ins.error = _("operands mismatch"); 2279 return; 2280 } 2281 2282 losing = 0; 2283 } 2284 2285 /* Now assemble it. */ 2286 the_ins.args = opcode->m_operands; 2287 the_ins.numargs = opcode->m_opnum; 2288 the_ins.numo = opcode->m_codenum; 2289 the_ins.opcode[0] = getone (opcode); 2290 the_ins.opcode[1] = gettwo (opcode); 2291 2292 for (s = the_ins.args, opP = &the_ins.operands[0]; *s; s += 2, opP++) 2293 { 2294 int have_disp = 0; 2295 int use_pl = 0; 2296 2297 /* This switch is a doozy. 2298 Watch the first step; its a big one! */ 2299 switch (s[0]) 2300 { 2301 2302 case '*': 2303 case '~': 2304 case '%': 2305 case ';': 2306 case '@': 2307 case '!': 2308 case '&': 2309 case '$': 2310 case '?': 2311 case '/': 2312 case '<': 2313 case '>': 2314 case 'b': 2315 case 'm': 2316 case 'n': 2317 case 'o': 2318 case 'p': 2319 case 'q': 2320 case 'v': 2321 case 'w': 2322 case 'y': 2323 case 'z': 2324 case '4': 2325 #ifndef NO_68851 2326 case '|': 2327 #endif 2328 switch (opP->mode) 2329 { 2330 case IMMED: 2331 tmpreg = 0x3c; /* 7.4 */ 2332 if (strchr ("bwl", s[1])) 2333 nextword = get_num (&opP->disp, 90); 2334 else 2335 nextword = get_num (&opP->disp, 0); 2336 if (isvar (&opP->disp)) 2337 add_fix (s[1], &opP->disp, 0, 0); 2338 switch (s[1]) 2339 { 2340 case 'b': 2341 if (!isbyte (nextword)) 2342 opP->error = _("operand out of range"); 2343 addword (nextword); 2344 baseo = 0; 2345 break; 2346 case 'w': 2347 if (!isword (nextword)) 2348 opP->error = _("operand out of range"); 2349 addword (nextword); 2350 baseo = 0; 2351 break; 2352 case 'W': 2353 if (!issword (nextword)) 2354 opP->error = _("operand out of range"); 2355 addword (nextword); 2356 baseo = 0; 2357 break; 2358 case 'l': 2359 addword (nextword >> 16); 2360 addword (nextword); 2361 baseo = 0; 2362 break; 2363 2364 case 'f': 2365 baseo = 2; 2366 outro = 8; 2367 break; 2368 case 'F': 2369 baseo = 4; 2370 outro = 11; 2371 break; 2372 case 'x': 2373 baseo = 6; 2374 outro = 15; 2375 break; 2376 case 'p': 2377 baseo = 6; 2378 outro = -1; 2379 break; 2380 default: 2381 abort (); 2382 } 2383 if (!baseo) 2384 break; 2385 2386 /* We gotta put out some float. */ 2387 if (op (&opP->disp) != O_big) 2388 { 2389 valueT val; 2390 int gencnt; 2391 2392 /* Can other cases happen here? */ 2393 if (op (&opP->disp) != O_constant) 2394 abort (); 2395 2396 val = (valueT) offs (&opP->disp); 2397 gencnt = 0; 2398 do 2399 { 2400 generic_bignum[gencnt] = (LITTLENUM_TYPE) val; 2401 val >>= LITTLENUM_NUMBER_OF_BITS; 2402 ++gencnt; 2403 } 2404 while (val != 0); 2405 offs (&opP->disp) = gencnt; 2406 } 2407 if (offs (&opP->disp) > 0) 2408 { 2409 if (offs (&opP->disp) > baseo) 2410 { 2411 as_warn (_("Bignum too big for %c format; truncated"), 2412 s[1]); 2413 offs (&opP->disp) = baseo; 2414 } 2415 baseo -= offs (&opP->disp); 2416 while (baseo--) 2417 addword (0); 2418 for (wordp = generic_bignum + offs (&opP->disp) - 1; 2419 offs (&opP->disp)--; 2420 --wordp) 2421 addword (*wordp); 2422 break; 2423 } 2424 gen_to_words (words, baseo, (long) outro); 2425 for (wordp = words; baseo--; wordp++) 2426 addword (*wordp); 2427 break; 2428 case DREG: 2429 tmpreg = opP->reg - DATA; /* 0.dreg */ 2430 break; 2431 case AREG: 2432 tmpreg = 0x08 + opP->reg - ADDR; /* 1.areg */ 2433 break; 2434 case AINDR: 2435 tmpreg = 0x10 + opP->reg - ADDR; /* 2.areg */ 2436 break; 2437 case ADEC: 2438 tmpreg = 0x20 + opP->reg - ADDR; /* 4.areg */ 2439 break; 2440 case AINC: 2441 tmpreg = 0x18 + opP->reg - ADDR; /* 3.areg */ 2442 break; 2443 case DISP: 2444 2445 nextword = get_num (&opP->disp, 90); 2446 2447 /* Convert mode 5 addressing with a zero offset into 2448 mode 2 addressing to reduce the instruction size by a 2449 word. */ 2450 if (! isvar (&opP->disp) 2451 && (nextword == 0) 2452 && (opP->disp.size == SIZE_UNSPEC) 2453 && (opP->reg >= ADDR0) 2454 && (opP->reg <= ADDR7)) 2455 { 2456 tmpreg = 0x10 + opP->reg - ADDR; /* 2.areg */ 2457 break; 2458 } 2459 2460 if (opP->reg == PC 2461 && ! isvar (&opP->disp) 2462 && m68k_abspcadd) 2463 { 2464 opP->disp.exp.X_op = O_symbol; 2465 opP->disp.exp.X_add_symbol = 2466 section_symbol (absolute_section); 2467 } 2468 2469 /* Force into index mode. Hope this works. */ 2470 2471 /* We do the first bit for 32-bit displacements, and the 2472 second bit for 16 bit ones. It is possible that we 2473 should make the default be WORD instead of LONG, but 2474 I think that'd break GCC, so we put up with a little 2475 inefficiency for the sake of working output. */ 2476 2477 if (!issword (nextword) 2478 || (isvar (&opP->disp) 2479 && ((opP->disp.size == SIZE_UNSPEC 2480 && flag_short_refs == 0 2481 && cpu_of_arch (current_architecture) >= m68020 2482 && ! arch_coldfire_p (current_architecture)) 2483 || opP->disp.size == SIZE_LONG))) 2484 { 2485 if (cpu_of_arch (current_architecture) < m68020 2486 || arch_coldfire_p (current_architecture)) 2487 opP->error = 2488 _("displacement too large for this architecture; needs 68020 or higher"); 2489 if (opP->reg == PC) 2490 tmpreg = 0x3B; /* 7.3 */ 2491 else 2492 tmpreg = 0x30 + opP->reg - ADDR; /* 6.areg */ 2493 if (isvar (&opP->disp)) 2494 { 2495 if (opP->reg == PC) 2496 { 2497 if (opP->disp.size == SIZE_LONG 2498 #ifdef OBJ_ELF 2499 /* If the displacement needs pic 2500 relocation it cannot be relaxed. */ 2501 || opP->disp.pic_reloc != pic_none 2502 #endif 2503 ) 2504 { 2505 addword (0x0170); 2506 add_fix ('l', &opP->disp, 1, 2); 2507 } 2508 else 2509 { 2510 add_frag (adds (&opP->disp), 2511 SEXT (offs (&opP->disp)), 2512 TAB (PCREL1632, SZ_UNDEF)); 2513 break; 2514 } 2515 } 2516 else 2517 { 2518 addword (0x0170); 2519 add_fix ('l', &opP->disp, 0, 0); 2520 } 2521 } 2522 else 2523 addword (0x0170); 2524 addword (nextword >> 16); 2525 } 2526 else 2527 { 2528 if (opP->reg == PC) 2529 tmpreg = 0x3A; /* 7.2 */ 2530 else 2531 tmpreg = 0x28 + opP->reg - ADDR; /* 5.areg */ 2532 2533 if (isvar (&opP->disp)) 2534 { 2535 if (opP->reg == PC) 2536 { 2537 add_fix ('w', &opP->disp, 1, 0); 2538 } 2539 else 2540 add_fix ('w', &opP->disp, 0, 0); 2541 } 2542 } 2543 addword (nextword); 2544 break; 2545 2546 case POST: 2547 case PRE: 2548 case BASE: 2549 nextword = 0; 2550 baseo = get_num (&opP->disp, 90); 2551 if (opP->mode == POST || opP->mode == PRE) 2552 outro = get_num (&opP->odisp, 90); 2553 /* Figure out the `addressing mode'. 2554 Also turn on the BASE_DISABLE bit, if needed. */ 2555 if (opP->reg == PC || opP->reg == ZPC) 2556 { 2557 tmpreg = 0x3b; /* 7.3 */ 2558 if (opP->reg == ZPC) 2559 nextword |= 0x80; 2560 } 2561 else if (opP->reg == 0) 2562 { 2563 nextword |= 0x80; 2564 tmpreg = 0x30; /* 6.garbage */ 2565 } 2566 else if (opP->reg >= ZADDR0 && opP->reg <= ZADDR7) 2567 { 2568 nextword |= 0x80; 2569 tmpreg = 0x30 + opP->reg - ZADDR0; 2570 } 2571 else 2572 tmpreg = 0x30 + opP->reg - ADDR; /* 6.areg */ 2573 2574 siz1 = opP->disp.size; 2575 if (opP->mode == POST || opP->mode == PRE) 2576 siz2 = opP->odisp.size; 2577 else 2578 siz2 = SIZE_UNSPEC; 2579 2580 /* Index register stuff. */ 2581 if (opP->index.reg != 0 2582 && opP->index.reg >= DATA 2583 && opP->index.reg <= ADDR7) 2584 { 2585 nextword |= (opP->index.reg - DATA) << 12; 2586 2587 if (opP->index.size == SIZE_LONG 2588 || (opP->index.size == SIZE_UNSPEC 2589 && m68k_index_width_default == SIZE_LONG)) 2590 nextword |= 0x800; 2591 2592 if ((opP->index.scale != 1 2593 && cpu_of_arch (current_architecture) < m68020) 2594 || (opP->index.scale == 8 2595 && (arch_coldfire_p (current_architecture) 2596 && !arch_coldfire_fpu (current_architecture)))) 2597 { 2598 opP->error = 2599 _("scale factor invalid on this architecture; needs cpu32 or 68020 or higher"); 2600 } 2601 2602 if (arch_coldfire_p (current_architecture) 2603 && opP->index.size == SIZE_WORD) 2604 opP->error = _("invalid index size for coldfire"); 2605 2606 switch (opP->index.scale) 2607 { 2608 case 1: 2609 break; 2610 case 2: 2611 nextword |= 0x200; 2612 break; 2613 case 4: 2614 nextword |= 0x400; 2615 break; 2616 case 8: 2617 nextword |= 0x600; 2618 break; 2619 default: 2620 abort (); 2621 } 2622 /* IF its simple, 2623 GET US OUT OF HERE! */ 2624 2625 /* Must be INDEX, with an index register. Address 2626 register cannot be ZERO-PC, and either :b was 2627 forced, or we know it will fit. For a 68000 or 2628 68010, force this mode anyways, because the 2629 larger modes aren't supported. */ 2630 if (opP->mode == BASE 2631 && ((opP->reg >= ADDR0 2632 && opP->reg <= ADDR7) 2633 || opP->reg == PC)) 2634 { 2635 if (siz1 == SIZE_BYTE 2636 || cpu_of_arch (current_architecture) < m68020 2637 || arch_coldfire_p (current_architecture) 2638 || (siz1 == SIZE_UNSPEC 2639 && ! isvar (&opP->disp) 2640 && issbyte (baseo))) 2641 { 2642 nextword += baseo & 0xff; 2643 addword (nextword); 2644 if (isvar (&opP->disp)) 2645 { 2646 /* Do a byte relocation. If it doesn't 2647 fit (possible on m68000) let the 2648 fixup processing complain later. */ 2649 if (opP->reg == PC) 2650 add_fix ('B', &opP->disp, 1, 1); 2651 else 2652 add_fix ('B', &opP->disp, 0, 0); 2653 } 2654 else if (siz1 != SIZE_BYTE) 2655 { 2656 if (siz1 != SIZE_UNSPEC) 2657 as_warn (_("Forcing byte displacement")); 2658 if (! issbyte (baseo)) 2659 opP->error = _("byte displacement out of range"); 2660 } 2661 2662 break; 2663 } 2664 else if (siz1 == SIZE_UNSPEC 2665 && opP->reg == PC 2666 && isvar (&opP->disp) 2667 && subs (&opP->disp) == NULL 2668 #ifdef OBJ_ELF 2669 /* If the displacement needs pic 2670 relocation it cannot be relaxed. */ 2671 && opP->disp.pic_reloc == pic_none 2672 #endif 2673 ) 2674 { 2675 /* The code in md_convert_frag_1 needs to be 2676 able to adjust nextword. Call frag_grow 2677 to ensure that we have enough space in 2678 the frag obstack to make all the bytes 2679 contiguous. */ 2680 frag_grow (14); 2681 nextword += baseo & 0xff; 2682 addword (nextword); 2683 add_frag (adds (&opP->disp), 2684 SEXT (offs (&opP->disp)), 2685 TAB (PCINDEX, SZ_UNDEF)); 2686 2687 break; 2688 } 2689 } 2690 } 2691 else 2692 { 2693 nextword |= 0x40; /* No index reg. */ 2694 if (opP->index.reg >= ZDATA0 2695 && opP->index.reg <= ZDATA7) 2696 nextword |= (opP->index.reg - ZDATA0) << 12; 2697 else if (opP->index.reg >= ZADDR0 2698 || opP->index.reg <= ZADDR7) 2699 nextword |= (opP->index.reg - ZADDR0 + 8) << 12; 2700 } 2701 2702 /* It isn't simple. */ 2703 2704 if (cpu_of_arch (current_architecture) < m68020 2705 || arch_coldfire_p (current_architecture)) 2706 opP->error = 2707 _("invalid operand mode for this architecture; needs 68020 or higher"); 2708 2709 nextword |= 0x100; 2710 /* If the guy specified a width, we assume that it is 2711 wide enough. Maybe it isn't. If so, we lose. */ 2712 switch (siz1) 2713 { 2714 case SIZE_UNSPEC: 2715 if (isvar (&opP->disp) 2716 ? m68k_rel32 2717 : ! issword (baseo)) 2718 { 2719 siz1 = SIZE_LONG; 2720 nextword |= 0x30; 2721 } 2722 else if (! isvar (&opP->disp) && baseo == 0) 2723 nextword |= 0x10; 2724 else 2725 { 2726 nextword |= 0x20; 2727 siz1 = SIZE_WORD; 2728 } 2729 break; 2730 case SIZE_BYTE: 2731 as_warn (_(":b not permitted; defaulting to :w")); 2732 /* Fall through. */ 2733 case SIZE_WORD: 2734 nextword |= 0x20; 2735 break; 2736 case SIZE_LONG: 2737 nextword |= 0x30; 2738 break; 2739 } 2740 2741 /* Figure out inner displacement stuff. */ 2742 if (opP->mode == POST || opP->mode == PRE) 2743 { 2744 if (cpu_of_arch (current_architecture) & cpu32) 2745 opP->error = _("invalid operand mode for this architecture; needs 68020 or higher"); 2746 switch (siz2) 2747 { 2748 case SIZE_UNSPEC: 2749 if (isvar (&opP->odisp) 2750 ? m68k_rel32 2751 : ! issword (outro)) 2752 { 2753 siz2 = SIZE_LONG; 2754 nextword |= 0x3; 2755 } 2756 else if (! isvar (&opP->odisp) && outro == 0) 2757 nextword |= 0x1; 2758 else 2759 { 2760 nextword |= 0x2; 2761 siz2 = SIZE_WORD; 2762 } 2763 break; 2764 case 1: 2765 as_warn (_(":b not permitted; defaulting to :w")); 2766 /* Fall through. */ 2767 case 2: 2768 nextword |= 0x2; 2769 break; 2770 case 3: 2771 nextword |= 0x3; 2772 break; 2773 } 2774 if (opP->mode == POST 2775 && (nextword & 0x40) == 0) 2776 nextword |= 0x04; 2777 } 2778 addword (nextword); 2779 2780 if (siz1 != SIZE_UNSPEC && isvar (&opP->disp)) 2781 { 2782 if (opP->reg == PC || opP->reg == ZPC) 2783 add_fix (siz1 == SIZE_LONG ? 'l' : 'w', &opP->disp, 1, 2); 2784 else 2785 add_fix (siz1 == SIZE_LONG ? 'l' : 'w', &opP->disp, 0, 0); 2786 } 2787 if (siz1 == SIZE_LONG) 2788 addword (baseo >> 16); 2789 if (siz1 != SIZE_UNSPEC) 2790 addword (baseo); 2791 2792 if (siz2 != SIZE_UNSPEC && isvar (&opP->odisp)) 2793 add_fix (siz2 == SIZE_LONG ? 'l' : 'w', &opP->odisp, 0, 0); 2794 if (siz2 == SIZE_LONG) 2795 addword (outro >> 16); 2796 if (siz2 != SIZE_UNSPEC) 2797 addword (outro); 2798 2799 break; 2800 2801 case ABSL: 2802 nextword = get_num (&opP->disp, 90); 2803 switch (opP->disp.size) 2804 { 2805 default: 2806 abort (); 2807 case SIZE_UNSPEC: 2808 if (!isvar (&opP->disp) && issword (offs (&opP->disp))) 2809 { 2810 tmpreg = 0x38; /* 7.0 */ 2811 addword (nextword); 2812 break; 2813 } 2814 if (isvar (&opP->disp) 2815 && !subs (&opP->disp) 2816 && adds (&opP->disp) 2817 #ifdef OBJ_ELF 2818 /* If the displacement needs pic relocation it 2819 cannot be relaxed. */ 2820 && opP->disp.pic_reloc == pic_none 2821 #endif 2822 && !flag_long_jumps 2823 && !strchr ("~%&$?", s[0])) 2824 { 2825 tmpreg = 0x3A; /* 7.2 */ 2826 add_frag (adds (&opP->disp), 2827 SEXT (offs (&opP->disp)), 2828 TAB (ABSTOPCREL, SZ_UNDEF)); 2829 break; 2830 } 2831 /* Fall through into long. */ 2832 case SIZE_LONG: 2833 if (isvar (&opP->disp)) 2834 add_fix ('l', &opP->disp, 0, 0); 2835 2836 tmpreg = 0x39;/* 7.1 mode */ 2837 addword (nextword >> 16); 2838 addword (nextword); 2839 break; 2840 2841 case SIZE_BYTE: 2842 as_bad (_("unsupported byte value; use a different suffix")); 2843 /* Fall through. */ 2844 2845 case SIZE_WORD: 2846 if (isvar (&opP->disp)) 2847 add_fix ('w', &opP->disp, 0, 0); 2848 2849 tmpreg = 0x38;/* 7.0 mode */ 2850 addword (nextword); 2851 break; 2852 } 2853 break; 2854 case CONTROL: 2855 case FPREG: 2856 default: 2857 as_bad (_("unknown/incorrect operand")); 2858 /* abort (); */ 2859 } 2860 2861 /* If s[0] is '4', then this is for the mac instructions 2862 that can have a trailing_ampersand set. If so, set 0x100 2863 bit on tmpreg so install_gen_operand can check for it and 2864 set the appropriate bit (word2, bit 5). */ 2865 if (s[0] == '4') 2866 { 2867 if (opP->trailing_ampersand) 2868 tmpreg |= 0x100; 2869 } 2870 install_gen_operand (s[1], tmpreg); 2871 break; 2872 2873 case '#': 2874 case '^': 2875 switch (s[1]) 2876 { /* JF: I hate floating point! */ 2877 case 'j': 2878 tmpreg = 70; 2879 break; 2880 case '8': 2881 tmpreg = 20; 2882 break; 2883 case 'C': 2884 tmpreg = 50; 2885 break; 2886 case '3': 2887 default: 2888 tmpreg = 90; 2889 break; 2890 } 2891 tmpreg = get_num (&opP->disp, tmpreg); 2892 if (isvar (&opP->disp)) 2893 add_fix (s[1], &opP->disp, 0, 0); 2894 switch (s[1]) 2895 { 2896 case 'b': /* Danger: These do no check for 2897 certain types of overflow. 2898 user beware! */ 2899 if (!isbyte (tmpreg)) 2900 opP->error = _("out of range"); 2901 insop (tmpreg, opcode); 2902 if (isvar (&opP->disp)) 2903 the_ins.reloc[the_ins.nrel - 1].n = 2904 (opcode->m_codenum) * 2 + 1; 2905 break; 2906 case 'B': 2907 if (!issbyte (tmpreg)) 2908 opP->error = _("out of range"); 2909 the_ins.opcode[the_ins.numo - 1] |= tmpreg & 0xff; 2910 if (isvar (&opP->disp)) 2911 the_ins.reloc[the_ins.nrel - 1].n = opcode->m_codenum * 2 - 1; 2912 break; 2913 case 'w': 2914 if (!isword (tmpreg)) 2915 opP->error = _("out of range"); 2916 insop (tmpreg, opcode); 2917 if (isvar (&opP->disp)) 2918 the_ins.reloc[the_ins.nrel - 1].n = (opcode->m_codenum) * 2; 2919 break; 2920 case 'W': 2921 if (!issword (tmpreg)) 2922 opP->error = _("out of range"); 2923 insop (tmpreg, opcode); 2924 if (isvar (&opP->disp)) 2925 the_ins.reloc[the_ins.nrel - 1].n = (opcode->m_codenum) * 2; 2926 break; 2927 case 'l': 2928 /* Because of the way insop works, we put these two out 2929 backwards. */ 2930 insop (tmpreg, opcode); 2931 insop (tmpreg >> 16, opcode); 2932 if (isvar (&opP->disp)) 2933 the_ins.reloc[the_ins.nrel - 1].n = (opcode->m_codenum) * 2; 2934 break; 2935 case '3': 2936 tmpreg &= 0xFF; 2937 case '8': 2938 case 'C': 2939 case 'j': 2940 install_operand (s[1], tmpreg); 2941 break; 2942 default: 2943 abort (); 2944 } 2945 break; 2946 2947 case '+': 2948 case '-': 2949 case 'A': 2950 case 'a': 2951 install_operand (s[1], opP->reg - ADDR); 2952 break; 2953 2954 case 'B': 2955 tmpreg = get_num (&opP->disp, 90); 2956 2957 switch (s[1]) 2958 { 2959 case 'B': 2960 add_fix ('B', &opP->disp, 1, -1); 2961 break; 2962 case 'W': 2963 add_fix ('w', &opP->disp, 1, 0); 2964 addword (0); 2965 break; 2966 case 'L': 2967 long_branch: 2968 the_ins.opcode[0] |= 0xff; 2969 add_fix ('l', &opP->disp, 1, 0); 2970 addword (0); 2971 addword (0); 2972 break; 2973 case 'g': /* Conditional branch */ 2974 have_disp = HAVE_LONG_CALL (current_architecture); 2975 goto var_branch; 2976 2977 case 'b': /* Unconditional branch */ 2978 have_disp = HAVE_LONG_BRANCH (current_architecture); 2979 use_pl = LONG_BRANCH_VIA_COND (current_architecture); 2980 goto var_branch; 2981 2982 case 's': /* Unconditional subroutine */ 2983 have_disp = HAVE_LONG_CALL (current_architecture); 2984 2985 var_branch: 2986 if (subs (&opP->disp) /* We can't relax it. */ 2987 #ifdef OBJ_ELF 2988 /* If the displacement needs pic relocation it cannot be 2989 relaxed. */ 2990 || opP->disp.pic_reloc != pic_none 2991 #endif 2992 || 0) 2993 { 2994 if (!have_disp) 2995 as_warn (_("Can't use long branches on this architecture")); 2996 goto long_branch; 2997 } 2998 2999 /* This could either be a symbol, or an absolute 3000 address. If it's an absolute address, turn it into 3001 an absolute jump right here and keep it out of the 3002 relaxer. */ 3003 if (adds (&opP->disp) == 0) 3004 { 3005 if (the_ins.opcode[0] == 0x6000) /* jbra */ 3006 the_ins.opcode[0] = 0x4EF9; 3007 else if (the_ins.opcode[0] == 0x6100) /* jbsr */ 3008 the_ins.opcode[0] = 0x4EB9; 3009 else /* jCC */ 3010 { 3011 the_ins.opcode[0] ^= 0x0100; 3012 the_ins.opcode[0] |= 0x0006; 3013 addword (0x4EF9); 3014 } 3015 add_fix ('l', &opP->disp, 0, 0); 3016 addword (0); 3017 addword (0); 3018 break; 3019 } 3020 3021 /* Now we know it's going into the relaxer. Now figure 3022 out which mode. We try in this order of preference: 3023 long branch, absolute jump, byte/word branches only. */ 3024 if (have_disp) 3025 add_frag (adds (&opP->disp), 3026 SEXT (offs (&opP->disp)), 3027 TAB (BRANCHBWL, SZ_UNDEF)); 3028 else if (! flag_keep_pcrel) 3029 { 3030 if ((the_ins.opcode[0] == 0x6000) 3031 || (the_ins.opcode[0] == 0x6100)) 3032 add_frag (adds (&opP->disp), 3033 SEXT (offs (&opP->disp)), 3034 TAB (BRABSJUNC, SZ_UNDEF)); 3035 else 3036 add_frag (adds (&opP->disp), 3037 SEXT (offs (&opP->disp)), 3038 TAB (BRABSJCOND, SZ_UNDEF)); 3039 } 3040 else 3041 add_frag (adds (&opP->disp), 3042 SEXT (offs (&opP->disp)), 3043 (use_pl ? TAB (BRANCHBWPL, SZ_UNDEF) 3044 : TAB (BRANCHBW, SZ_UNDEF))); 3045 break; 3046 case 'w': 3047 if (isvar (&opP->disp)) 3048 { 3049 /* Check for DBcc instructions. We can relax them, 3050 but only if we have long branches and/or absolute 3051 jumps. */ 3052 if (((the_ins.opcode[0] & 0xf0f8) == 0x50c8) 3053 && (HAVE_LONG_BRANCH (current_architecture) 3054 || ! flag_keep_pcrel)) 3055 { 3056 if (HAVE_LONG_BRANCH (current_architecture)) 3057 add_frag (adds (&opP->disp), 3058 SEXT (offs (&opP->disp)), 3059 TAB (DBCCLBR, SZ_UNDEF)); 3060 else 3061 add_frag (adds (&opP->disp), 3062 SEXT (offs (&opP->disp)), 3063 TAB (DBCCABSJ, SZ_UNDEF)); 3064 break; 3065 } 3066 add_fix ('w', &opP->disp, 1, 0); 3067 } 3068 addword (0); 3069 break; 3070 case 'C': /* Fixed size LONG coproc branches. */ 3071 add_fix ('l', &opP->disp, 1, 0); 3072 addword (0); 3073 addword (0); 3074 break; 3075 case 'c': /* Var size Coprocesssor branches. */ 3076 if (subs (&opP->disp) || (adds (&opP->disp) == 0)) 3077 { 3078 the_ins.opcode[the_ins.numo - 1] |= 0x40; 3079 add_fix ('l', &opP->disp, 1, 0); 3080 addword (0); 3081 addword (0); 3082 } 3083 else 3084 add_frag (adds (&opP->disp), 3085 SEXT (offs (&opP->disp)), 3086 TAB (FBRANCH, SZ_UNDEF)); 3087 break; 3088 default: 3089 abort (); 3090 } 3091 break; 3092 3093 case 'C': /* Ignore it. */ 3094 break; 3095 3096 case 'd': /* JF this is a kludge. */ 3097 install_operand ('s', opP->reg - ADDR); 3098 tmpreg = get_num (&opP->disp, 90); 3099 if (!issword (tmpreg)) 3100 { 3101 as_warn (_("Expression out of range, using 0")); 3102 tmpreg = 0; 3103 } 3104 addword (tmpreg); 3105 break; 3106 3107 case 'D': 3108 install_operand (s[1], opP->reg - DATA); 3109 break; 3110 3111 case 'e': /* EMAC ACCx, reg/reg. */ 3112 install_operand (s[1], opP->reg - ACC); 3113 break; 3114 3115 case 'E': /* Ignore it. */ 3116 break; 3117 3118 case 'F': 3119 install_operand (s[1], opP->reg - FP0); 3120 break; 3121 3122 case 'g': /* EMAC ACCEXTx. */ 3123 install_operand (s[1], opP->reg - ACCEXT01); 3124 break; 3125 3126 case 'G': /* Ignore it. */ 3127 case 'H': 3128 break; 3129 3130 case 'I': 3131 tmpreg = opP->reg - COP0; 3132 install_operand (s[1], tmpreg); 3133 break; 3134 3135 case 'i': /* MAC/EMAC scale factor. */ 3136 install_operand (s[1], opP->mode == LSH ? 0x1 : 0x3); 3137 break; 3138 3139 case 'J': /* JF foo. */ 3140 switch (opP->reg) 3141 { 3142 case SFC: 3143 tmpreg = 0x000; 3144 break; 3145 case DFC: 3146 tmpreg = 0x001; 3147 break; 3148 case CACR: 3149 tmpreg = 0x002; 3150 break; 3151 case TC: 3152 case ASID: 3153 tmpreg = 0x003; 3154 break; 3155 case ACR0: 3156 case ITT0: 3157 tmpreg = 0x004; 3158 break; 3159 case ACR1: 3160 case ITT1: 3161 tmpreg = 0x005; 3162 break; 3163 case ACR2: 3164 case DTT0: 3165 tmpreg = 0x006; 3166 break; 3167 case ACR3: 3168 case DTT1: 3169 tmpreg = 0x007; 3170 break; 3171 case BUSCR: 3172 case MMUBAR: 3173 tmpreg = 0x008; 3174 break; 3175 3176 case USP: 3177 tmpreg = 0x800; 3178 break; 3179 case VBR: 3180 tmpreg = 0x801; 3181 break; 3182 case CAAR: 3183 tmpreg = 0x802; 3184 break; 3185 case MSP: 3186 tmpreg = 0x803; 3187 break; 3188 case ISP: 3189 tmpreg = 0x804; 3190 break; 3191 case MMUSR: 3192 tmpreg = 0x805; 3193 break; 3194 case URP: 3195 tmpreg = 0x806; 3196 break; 3197 case SRP: 3198 tmpreg = 0x807; 3199 break; 3200 case PCR: 3201 tmpreg = 0x808; 3202 break; 3203 case ROMBAR: 3204 case ROMBAR0: 3205 tmpreg = 0xC00; 3206 break; 3207 case ROMBAR1: 3208 tmpreg = 0xC01; 3209 break; 3210 case FLASHBAR: 3211 case RAMBAR0: 3212 case RAMBAR_ALT: 3213 tmpreg = 0xC04; 3214 break; 3215 case RAMBAR: 3216 case RAMBAR1: 3217 tmpreg = 0xC05; 3218 break; 3219 case MPCR: 3220 tmpreg = 0xC0C; 3221 break; 3222 case EDRAMBAR: 3223 tmpreg = 0xC0D; 3224 break; 3225 case MBAR0: 3226 case MBAR2: 3227 case SECMBAR: 3228 tmpreg = 0xC0E; 3229 break; 3230 case MBAR1: 3231 case MBAR: 3232 tmpreg = 0xC0F; 3233 break; 3234 case PCR1U0: 3235 tmpreg = 0xD02; 3236 break; 3237 case PCR1L0: 3238 tmpreg = 0xD03; 3239 break; 3240 case PCR2U0: 3241 tmpreg = 0xD04; 3242 break; 3243 case PCR2L0: 3244 tmpreg = 0xD05; 3245 break; 3246 case PCR3U0: 3247 tmpreg = 0xD06; 3248 break; 3249 case PCR3L0: 3250 tmpreg = 0xD07; 3251 break; 3252 case PCR1L1: 3253 tmpreg = 0xD0A; 3254 break; 3255 case PCR1U1: 3256 tmpreg = 0xD0B; 3257 break; 3258 case PCR2L1: 3259 tmpreg = 0xD0C; 3260 break; 3261 case PCR2U1: 3262 tmpreg = 0xD0D; 3263 break; 3264 case PCR3L1: 3265 tmpreg = 0xD0E; 3266 break; 3267 case PCR3U1: 3268 tmpreg = 0xD0F; 3269 break; 3270 case CAC: 3271 tmpreg = 0xFFE; 3272 break; 3273 case MBO: 3274 tmpreg = 0xFFF; 3275 break; 3276 default: 3277 abort (); 3278 } 3279 install_operand (s[1], tmpreg); 3280 break; 3281 3282 case 'k': 3283 tmpreg = get_num (&opP->disp, 55); 3284 install_operand (s[1], tmpreg & 0x7f); 3285 break; 3286 3287 case 'l': 3288 tmpreg = opP->mask; 3289 if (s[1] == 'w') 3290 { 3291 if (tmpreg & 0x7FF0000) 3292 as_bad (_("Floating point register in register list")); 3293 insop (reverse_16_bits (tmpreg), opcode); 3294 } 3295 else 3296 { 3297 if (tmpreg & 0x700FFFF) 3298 as_bad (_("Wrong register in floating-point reglist")); 3299 install_operand (s[1], reverse_8_bits (tmpreg >> 16)); 3300 } 3301 break; 3302 3303 case 'L': 3304 tmpreg = opP->mask; 3305 if (s[1] == 'w') 3306 { 3307 if (tmpreg & 0x7FF0000) 3308 as_bad (_("Floating point register in register list")); 3309 insop (tmpreg, opcode); 3310 } 3311 else if (s[1] == '8') 3312 { 3313 if (tmpreg & 0x0FFFFFF) 3314 as_bad (_("incorrect register in reglist")); 3315 install_operand (s[1], tmpreg >> 24); 3316 } 3317 else 3318 { 3319 if (tmpreg & 0x700FFFF) 3320 as_bad (_("wrong register in floating-point reglist")); 3321 else 3322 install_operand (s[1], tmpreg >> 16); 3323 } 3324 break; 3325 3326 case 'M': 3327 install_operand (s[1], get_num (&opP->disp, 60)); 3328 break; 3329 3330 case 'O': 3331 tmpreg = ((opP->mode == DREG) 3332 ? 0x20 + (int) (opP->reg - DATA) 3333 : (get_num (&opP->disp, 40) & 0x1F)); 3334 install_operand (s[1], tmpreg); 3335 break; 3336 3337 case 'Q': 3338 tmpreg = get_num (&opP->disp, 10); 3339 if (tmpreg == 8) 3340 tmpreg = 0; 3341 install_operand (s[1], tmpreg); 3342 break; 3343 3344 case 'R': 3345 /* This depends on the fact that ADDR registers are eight 3346 more than their corresponding DATA regs, so the result 3347 will have the ADDR_REG bit set. */ 3348 install_operand (s[1], opP->reg - DATA); 3349 break; 3350 3351 case 'r': 3352 if (opP->mode == AINDR) 3353 install_operand (s[1], opP->reg - DATA); 3354 else 3355 install_operand (s[1], opP->index.reg - DATA); 3356 break; 3357 3358 case 's': 3359 if (opP->reg == FPI) 3360 tmpreg = 0x1; 3361 else if (opP->reg == FPS) 3362 tmpreg = 0x2; 3363 else if (opP->reg == FPC) 3364 tmpreg = 0x4; 3365 else 3366 abort (); 3367 install_operand (s[1], tmpreg); 3368 break; 3369 3370 case 'S': /* Ignore it. */ 3371 break; 3372 3373 case 'T': 3374 install_operand (s[1], get_num (&opP->disp, 30)); 3375 break; 3376 3377 case 'U': /* Ignore it. */ 3378 break; 3379 3380 case 'c': 3381 switch (opP->reg) 3382 { 3383 case NC: 3384 tmpreg = 0; 3385 break; 3386 case DC: 3387 tmpreg = 1; 3388 break; 3389 case IC: 3390 tmpreg = 2; 3391 break; 3392 case BC: 3393 tmpreg = 3; 3394 break; 3395 default: 3396 as_fatal (_("failed sanity check")); 3397 } /* switch on cache token. */ 3398 install_operand (s[1], tmpreg); 3399 break; 3400 #ifndef NO_68851 3401 /* JF: These are out of order, I fear. */ 3402 case 'f': 3403 switch (opP->reg) 3404 { 3405 case SFC: 3406 tmpreg = 0; 3407 break; 3408 case DFC: 3409 tmpreg = 1; 3410 break; 3411 default: 3412 abort (); 3413 } 3414 install_operand (s[1], tmpreg); 3415 break; 3416 3417 case '0': 3418 case '1': 3419 case '2': 3420 switch (opP->reg) 3421 { 3422 case TC: 3423 tmpreg = 0; 3424 break; 3425 case CAL: 3426 tmpreg = 4; 3427 break; 3428 case VAL: 3429 tmpreg = 5; 3430 break; 3431 case SCC: 3432 tmpreg = 6; 3433 break; 3434 case AC: 3435 tmpreg = 7; 3436 break; 3437 default: 3438 abort (); 3439 } 3440 install_operand (s[1], tmpreg); 3441 break; 3442 3443 case 'V': 3444 if (opP->reg == VAL) 3445 break; 3446 abort (); 3447 3448 case 'W': 3449 switch (opP->reg) 3450 { 3451 case DRP: 3452 tmpreg = 1; 3453 break; 3454 case SRP: 3455 tmpreg = 2; 3456 break; 3457 case CRP: 3458 tmpreg = 3; 3459 break; 3460 default: 3461 abort (); 3462 } 3463 install_operand (s[1], tmpreg); 3464 break; 3465 3466 case 'X': 3467 switch (opP->reg) 3468 { 3469 case BAD: 3470 case BAD + 1: 3471 case BAD + 2: 3472 case BAD + 3: 3473 case BAD + 4: 3474 case BAD + 5: 3475 case BAD + 6: 3476 case BAD + 7: 3477 tmpreg = (4 << 10) | ((opP->reg - BAD) << 2); 3478 break; 3479 3480 case BAC: 3481 case BAC + 1: 3482 case BAC + 2: 3483 case BAC + 3: 3484 case BAC + 4: 3485 case BAC + 5: 3486 case BAC + 6: 3487 case BAC + 7: 3488 tmpreg = (5 << 10) | ((opP->reg - BAC) << 2); 3489 break; 3490 3491 default: 3492 abort (); 3493 } 3494 install_operand (s[1], tmpreg); 3495 break; 3496 case 'Y': 3497 know (opP->reg == PSR); 3498 break; 3499 case 'Z': 3500 know (opP->reg == PCSR); 3501 break; 3502 #endif /* m68851 */ 3503 case '3': 3504 switch (opP->reg) 3505 { 3506 case TT0: 3507 tmpreg = 2; 3508 break; 3509 case TT1: 3510 tmpreg = 3; 3511 break; 3512 default: 3513 abort (); 3514 } 3515 install_operand (s[1], tmpreg); 3516 break; 3517 case 't': 3518 tmpreg = get_num (&opP->disp, 20); 3519 install_operand (s[1], tmpreg); 3520 break; 3521 case '_': /* used only for move16 absolute 32-bit address. */ 3522 if (isvar (&opP->disp)) 3523 add_fix ('l', &opP->disp, 0, 0); 3524 tmpreg = get_num (&opP->disp, 90); 3525 addword (tmpreg >> 16); 3526 addword (tmpreg & 0xFFFF); 3527 break; 3528 case 'u': 3529 install_operand (s[1], opP->reg - DATA0L); 3530 opP->reg -= (DATA0L); 3531 opP->reg &= 0x0F; /* remove upper/lower bit. */ 3532 break; 3533 case 'x': 3534 tmpreg = get_num (&opP->disp, 80); 3535 if (tmpreg == -1) 3536 tmpreg = 0; 3537 install_operand (s[1], tmpreg); 3538 break; 3539 case 'j': 3540 tmpreg = get_num (&opP->disp, 10); 3541 install_operand (s[1], tmpreg - 1); 3542 break; 3543 case 'K': 3544 tmpreg = get_num (&opP->disp, 65); 3545 install_operand (s[1], tmpreg); 3546 break; 3547 default: 3548 abort (); 3549 } 3550 } 3551 3552 /* By the time whe get here (FINALLY) the_ins contains the complete 3553 instruction, ready to be emitted. . . */ 3554 } 3555 3556 static int 3557 reverse_16_bits (int in) 3558 { 3559 int out = 0; 3560 int n; 3561 3562 static int mask[16] = 3563 { 3564 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080, 3565 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000, 0x8000 3566 }; 3567 for (n = 0; n < 16; n++) 3568 { 3569 if (in & mask[n]) 3570 out |= mask[15 - n]; 3571 } 3572 return out; 3573 } /* reverse_16_bits() */ 3574 3575 static int 3576 reverse_8_bits (int in) 3577 { 3578 int out = 0; 3579 int n; 3580 3581 static int mask[8] = 3582 { 3583 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080, 3584 }; 3585 3586 for (n = 0; n < 8; n++) 3587 { 3588 if (in & mask[n]) 3589 out |= mask[7 - n]; 3590 } 3591 return out; 3592 } /* reverse_8_bits() */ 3593 3594 /* Cause an extra frag to be generated here, inserting up to 3595 FRAG_VAR_SIZE bytes. TYPE is the subtype of the frag to be 3596 generated; its primary type is rs_machine_dependent. 3597 3598 The TYPE parameter is also used by md_convert_frag_1 and 3599 md_estimate_size_before_relax. The appropriate type of fixup will 3600 be emitted by md_convert_frag_1. 3601 3602 ADD becomes the FR_SYMBOL field of the frag, and OFF the FR_OFFSET. */ 3603 static void 3604 install_operand (int mode, int val) 3605 { 3606 switch (mode) 3607 { 3608 case 's': 3609 the_ins.opcode[0] |= val & 0xFF; /* JF FF is for M kludge. */ 3610 break; 3611 case 'd': 3612 the_ins.opcode[0] |= val << 9; 3613 break; 3614 case 'E': 3615 the_ins.opcode[1] |= val << 9; 3616 break; 3617 case '1': 3618 the_ins.opcode[1] |= val << 12; 3619 break; 3620 case '2': 3621 the_ins.opcode[1] |= val << 6; 3622 break; 3623 case '3': 3624 the_ins.opcode[1] |= val; 3625 break; 3626 case '4': 3627 the_ins.opcode[2] |= val << 12; 3628 break; 3629 case '5': 3630 the_ins.opcode[2] |= val << 6; 3631 break; 3632 case '6': 3633 /* DANGER! This is a hack to force cas2l and cas2w cmds to be 3634 three words long! */ 3635 the_ins.numo++; 3636 the_ins.opcode[2] |= val; 3637 break; 3638 case '7': 3639 the_ins.opcode[1] |= val << 7; 3640 break; 3641 case '8': 3642 the_ins.opcode[1] |= val << 10; 3643 break; 3644 #ifndef NO_68851 3645 case '9': 3646 the_ins.opcode[1] |= val << 5; 3647 break; 3648 #endif 3649 3650 case 't': 3651 the_ins.opcode[1] |= (val << 10) | (val << 7); 3652 break; 3653 case 'D': 3654 the_ins.opcode[1] |= (val << 12) | val; 3655 break; 3656 case 'g': 3657 the_ins.opcode[0] |= val = 0xff; 3658 break; 3659 case 'i': 3660 the_ins.opcode[0] |= val << 9; 3661 break; 3662 case 'C': 3663 the_ins.opcode[1] |= val; 3664 break; 3665 case 'j': 3666 the_ins.opcode[1] |= val; 3667 the_ins.numo++; /* What a hack. */ 3668 break; 3669 case 'k': 3670 the_ins.opcode[1] |= val << 4; 3671 break; 3672 case 'b': 3673 case 'w': 3674 case 'W': 3675 case 'l': 3676 break; 3677 case 'e': 3678 the_ins.opcode[0] |= (val << 6); 3679 break; 3680 case 'L': 3681 the_ins.opcode[1] = (val >> 16); 3682 the_ins.opcode[2] = val & 0xffff; 3683 break; 3684 case 'm': 3685 the_ins.opcode[0] |= ((val & 0x8) << (6 - 3)); 3686 the_ins.opcode[0] |= ((val & 0x7) << 9); 3687 the_ins.opcode[1] |= ((val & 0x10) << (7 - 4)); 3688 break; 3689 case 'n': /* MAC/EMAC Rx on !load. */ 3690 the_ins.opcode[0] |= ((val & 0x8) << (6 - 3)); 3691 the_ins.opcode[0] |= ((val & 0x7) << 9); 3692 the_ins.opcode[1] |= ((val & 0x10) << (7 - 4)); 3693 break; 3694 case 'o': /* MAC/EMAC Rx on load. */ 3695 the_ins.opcode[1] |= val << 12; 3696 the_ins.opcode[1] |= ((val & 0x10) << (7 - 4)); 3697 break; 3698 case 'M': /* MAC/EMAC Ry on !load. */ 3699 the_ins.opcode[0] |= (val & 0xF); 3700 the_ins.opcode[1] |= ((val & 0x10) << (6 - 4)); 3701 break; 3702 case 'N': /* MAC/EMAC Ry on load. */ 3703 the_ins.opcode[1] |= (val & 0xF); 3704 the_ins.opcode[1] |= ((val & 0x10) << (6 - 4)); 3705 break; 3706 case 'h': 3707 the_ins.opcode[1] |= ((val != 1) << 10); 3708 break; 3709 case 'F': 3710 the_ins.opcode[0] |= ((val & 0x3) << 9); 3711 break; 3712 case 'f': 3713 the_ins.opcode[0] |= ((val & 0x3) << 0); 3714 break; 3715 case 'G': /* EMAC accumulator in a EMAC load instruction. */ 3716 the_ins.opcode[0] |= ((~val & 0x1) << 7); 3717 the_ins.opcode[1] |= ((val & 0x2) << (4 - 1)); 3718 break; 3719 case 'H': /* EMAC accumulator in a EMAC non-load instruction. */ 3720 the_ins.opcode[0] |= ((val & 0x1) << 7); 3721 the_ins.opcode[1] |= ((val & 0x2) << (4 - 1)); 3722 break; 3723 case 'I': 3724 the_ins.opcode[1] |= ((val & 0x3) << 9); 3725 break; 3726 case ']': 3727 the_ins.opcode[0] |= (val & 0x1) <<10; 3728 break; 3729 case 'c': 3730 default: 3731 as_fatal (_("failed sanity check.")); 3732 } 3733 } 3734 3735 static void 3736 install_gen_operand (int mode, int val) 3737 { 3738 switch (mode) 3739 { 3740 case '/': /* Special for mask loads for mac/msac insns with 3741 possible mask; trailing_ampersend set in bit 8. */ 3742 the_ins.opcode[0] |= (val & 0x3f); 3743 the_ins.opcode[1] |= (((val & 0x100) >> 8) << 5); 3744 break; 3745 case 's': 3746 the_ins.opcode[0] |= val; 3747 break; 3748 case 'd': 3749 /* This is a kludge!!! */ 3750 the_ins.opcode[0] |= (val & 0x07) << 9 | (val & 0x38) << 3; 3751 break; 3752 case 'b': 3753 case 'w': 3754 case 'l': 3755 case 'f': 3756 case 'F': 3757 case 'x': 3758 case 'p': 3759 the_ins.opcode[0] |= val; 3760 break; 3761 /* more stuff goes here. */ 3762 default: 3763 as_fatal (_("failed sanity check.")); 3764 } 3765 } 3766 3767 /* Verify that we have some number of paren pairs, do m68k_ip_op(), and 3768 then deal with the bitfield hack. */ 3769 3770 static char * 3771 crack_operand (char *str, struct m68k_op *opP) 3772 { 3773 register int parens; 3774 register int c; 3775 register char *beg_str; 3776 int inquote = 0; 3777 3778 if (!str) 3779 { 3780 return str; 3781 } 3782 beg_str = str; 3783 for (parens = 0; *str && (parens > 0 || inquote || notend (str)); str++) 3784 { 3785 if (! inquote) 3786 { 3787 if (*str == '(') 3788 parens++; 3789 else if (*str == ')') 3790 { 3791 if (!parens) 3792 { /* ERROR. */ 3793 opP->error = _("Extra )"); 3794 return str; 3795 } 3796 --parens; 3797 } 3798 } 3799 if (flag_mri && *str == '\'') 3800 inquote = ! inquote; 3801 } 3802 if (!*str && parens) 3803 { /* ERROR. */ 3804 opP->error = _("Missing )"); 3805 return str; 3806 } 3807 c = *str; 3808 *str = '\0'; 3809 if (m68k_ip_op (beg_str, opP) != 0) 3810 { 3811 *str = c; 3812 return str; 3813 } 3814 *str = c; 3815 if (c == '}') 3816 c = *++str; /* JF bitfield hack. */ 3817 if (c) 3818 { 3819 c = *++str; 3820 if (!c) 3821 as_bad (_("Missing operand")); 3822 } 3823 3824 /* Detect MRI REG symbols and convert them to REGLSTs. */ 3825 if (opP->mode == CONTROL && (int)opP->reg < 0) 3826 { 3827 opP->mode = REGLST; 3828 opP->mask = ~(int)opP->reg; 3829 opP->reg = 0; 3830 } 3831 3832 return str; 3833 } 3834 3835 /* This is the guts of the machine-dependent assembler. STR points to a 3836 machine dependent instruction. This function is supposed to emit 3837 the frags/bytes it assembles to. 3838 */ 3839 3840 static void 3841 insert_reg (const char *regname, int regnum) 3842 { 3843 char buf[100]; 3844 int i; 3845 3846 #ifdef REGISTER_PREFIX 3847 if (!flag_reg_prefix_optional) 3848 { 3849 buf[0] = REGISTER_PREFIX; 3850 strcpy (buf + 1, regname); 3851 regname = buf; 3852 } 3853 #endif 3854 3855 symbol_table_insert (symbol_new (regname, reg_section, regnum, 3856 &zero_address_frag)); 3857 3858 for (i = 0; regname[i]; i++) 3859 buf[i] = TOUPPER (regname[i]); 3860 buf[i] = '\0'; 3861 3862 symbol_table_insert (symbol_new (buf, reg_section, regnum, 3863 &zero_address_frag)); 3864 } 3865 3866 struct init_entry 3867 { 3868 const char *name; 3869 int number; 3870 }; 3871 3872 static const struct init_entry init_table[] = 3873 { 3874 { "d0", DATA0 }, 3875 { "d1", DATA1 }, 3876 { "d2", DATA2 }, 3877 { "d3", DATA3 }, 3878 { "d4", DATA4 }, 3879 { "d5", DATA5 }, 3880 { "d6", DATA6 }, 3881 { "d7", DATA7 }, 3882 { "a0", ADDR0 }, 3883 { "a1", ADDR1 }, 3884 { "a2", ADDR2 }, 3885 { "a3", ADDR3 }, 3886 { "a4", ADDR4 }, 3887 { "a5", ADDR5 }, 3888 { "a6", ADDR6 }, 3889 { "fp", ADDR6 }, 3890 { "a7", ADDR7 }, 3891 { "sp", ADDR7 }, 3892 { "ssp", ADDR7 }, 3893 { "fp0", FP0 }, 3894 { "fp1", FP1 }, 3895 { "fp2", FP2 }, 3896 { "fp3", FP3 }, 3897 { "fp4", FP4 }, 3898 { "fp5", FP5 }, 3899 { "fp6", FP6 }, 3900 { "fp7", FP7 }, 3901 { "fpi", FPI }, 3902 { "fpiar", FPI }, 3903 { "fpc", FPI }, 3904 { "fps", FPS }, 3905 { "fpsr", FPS }, 3906 { "fpc", FPC }, 3907 { "fpcr", FPC }, 3908 { "control", FPC }, 3909 { "status", FPS }, 3910 { "iaddr", FPI }, 3911 3912 { "cop0", COP0 }, 3913 { "cop1", COP1 }, 3914 { "cop2", COP2 }, 3915 { "cop3", COP3 }, 3916 { "cop4", COP4 }, 3917 { "cop5", COP5 }, 3918 { "cop6", COP6 }, 3919 { "cop7", COP7 }, 3920 { "pc", PC }, 3921 { "zpc", ZPC }, 3922 { "sr", SR }, 3923 3924 { "ccr", CCR }, 3925 { "cc", CCR }, 3926 3927 { "acc", ACC }, 3928 { "acc0", ACC }, 3929 { "acc1", ACC1 }, 3930 { "acc2", ACC2 }, 3931 { "acc3", ACC3 }, 3932 { "accext01", ACCEXT01 }, 3933 { "accext23", ACCEXT23 }, 3934 { "macsr", MACSR }, 3935 { "mask", MASK }, 3936 3937 /* Control registers. */ 3938 { "sfc", SFC }, /* Source Function Code. */ 3939 { "sfcr", SFC }, 3940 { "dfc", DFC }, /* Destination Function Code. */ 3941 { "dfcr", DFC }, 3942 { "cacr", CACR }, /* Cache Control Register. */ 3943 { "caar", CAAR }, /* Cache Address Register. */ 3944 3945 { "usp", USP }, /* User Stack Pointer. */ 3946 { "vbr", VBR }, /* Vector Base Register. */ 3947 { "msp", MSP }, /* Master Stack Pointer. */ 3948 { "isp", ISP }, /* Interrupt Stack Pointer. */ 3949 3950 { "itt0", ITT0 }, /* Instruction Transparent Translation Reg 0. */ 3951 { "itt1", ITT1 }, /* Instruction Transparent Translation Reg 1. */ 3952 { "dtt0", DTT0 }, /* Data Transparent Translation Register 0. */ 3953 { "dtt1", DTT1 }, /* Data Transparent Translation Register 1. */ 3954 3955 /* 68ec040 versions of same */ 3956 { "iacr0", ITT0 }, /* Instruction Access Control Register 0. */ 3957 { "iacr1", ITT1 }, /* Instruction Access Control Register 0. */ 3958 { "dacr0", DTT0 }, /* Data Access Control Register 0. */ 3959 { "dacr1", DTT1 }, /* Data Access Control Register 0. */ 3960 3961 /* Coldfire versions of same. The ColdFire programmer's reference 3962 manual indicated that the order is 2,3,0,1, but Ken Rose 3963 <rose@netcom.com> says that 0,1,2,3 is the correct order. */ 3964 { "acr0", ACR0 }, /* Access Control Unit 0. */ 3965 { "acr1", ACR1 }, /* Access Control Unit 1. */ 3966 { "acr2", ACR2 }, /* Access Control Unit 2. */ 3967 { "acr3", ACR3 }, /* Access Control Unit 3. */ 3968 3969 { "tc", TC }, /* MMU Translation Control Register. */ 3970 { "tcr", TC }, 3971 { "asid", ASID }, 3972 3973 { "mmusr", MMUSR }, /* MMU Status Register. */ 3974 { "srp", SRP }, /* User Root Pointer. */ 3975 { "urp", URP }, /* Supervisor Root Pointer. */ 3976 3977 { "buscr", BUSCR }, 3978 { "mmubar", MMUBAR }, 3979 { "pcr", PCR }, 3980 3981 { "rombar", ROMBAR }, /* ROM Base Address Register. */ 3982 { "rambar0", RAMBAR0 }, /* ROM Base Address Register. */ 3983 { "rambar1", RAMBAR1 }, /* ROM Base Address Register. */ 3984 { "mbar", MBAR }, /* Module Base Address Register. */ 3985 3986 { "mbar0", MBAR0 }, /* mcfv4e registers. */ 3987 { "mbar1", MBAR1 }, /* mcfv4e registers. */ 3988 { "rombar0", ROMBAR0 }, /* mcfv4e registers. */ 3989 { "rombar1", ROMBAR1 }, /* mcfv4e registers. */ 3990 { "mpcr", MPCR }, /* mcfv4e registers. */ 3991 { "edrambar", EDRAMBAR }, /* mcfv4e registers. */ 3992 { "secmbar", SECMBAR }, /* mcfv4e registers. */ 3993 { "asid", TC }, /* mcfv4e registers. */ 3994 { "mmubar", BUSCR }, /* mcfv4e registers. */ 3995 { "pcr1u0", PCR1U0 }, /* mcfv4e registers. */ 3996 { "pcr1l0", PCR1L0 }, /* mcfv4e registers. */ 3997 { "pcr2u0", PCR2U0 }, /* mcfv4e registers. */ 3998 { "pcr2l0", PCR2L0 }, /* mcfv4e registers. */ 3999 { "pcr3u0", PCR3U0 }, /* mcfv4e registers. */ 4000 { "pcr3l0", PCR3L0 }, /* mcfv4e registers. */ 4001 { "pcr1u1", PCR1U1 }, /* mcfv4e registers. */ 4002 { "pcr1l1", PCR1L1 }, /* mcfv4e registers. */ 4003 { "pcr2u1", PCR2U1 }, /* mcfv4e registers. */ 4004 { "pcr2l1", PCR2L1 }, /* mcfv4e registers. */ 4005 { "pcr3u1", PCR3U1 }, /* mcfv4e registers. */ 4006 { "pcr3l1", PCR3L1 }, /* mcfv4e registers. */ 4007 4008 { "flashbar", FLASHBAR }, /* mcf528x registers. */ 4009 { "rambar", RAMBAR }, /* mcf528x registers. */ 4010 4011 { "mbar2", MBAR2 }, /* mcf5249 registers. */ 4012 4013 { "cac", CAC }, /* fido registers. */ 4014 { "mbb", MBO }, /* fido registers (obsolete). */ 4015 { "mbo", MBO }, /* fido registers. */ 4016 /* End of control registers. */ 4017 4018 { "ac", AC }, 4019 { "bc", BC }, 4020 { "cal", CAL }, 4021 { "crp", CRP }, 4022 { "drp", DRP }, 4023 { "pcsr", PCSR }, 4024 { "psr", PSR }, 4025 { "scc", SCC }, 4026 { "val", VAL }, 4027 { "bad0", BAD0 }, 4028 { "bad1", BAD1 }, 4029 { "bad2", BAD2 }, 4030 { "bad3", BAD3 }, 4031 { "bad4", BAD4 }, 4032 { "bad5", BAD5 }, 4033 { "bad6", BAD6 }, 4034 { "bad7", BAD7 }, 4035 { "bac0", BAC0 }, 4036 { "bac1", BAC1 }, 4037 { "bac2", BAC2 }, 4038 { "bac3", BAC3 }, 4039 { "bac4", BAC4 }, 4040 { "bac5", BAC5 }, 4041 { "bac6", BAC6 }, 4042 { "bac7", BAC7 }, 4043 4044 { "ic", IC }, 4045 { "dc", DC }, 4046 { "nc", NC }, 4047 4048 { "tt0", TT0 }, 4049 { "tt1", TT1 }, 4050 /* 68ec030 versions of same. */ 4051 { "ac0", TT0 }, 4052 { "ac1", TT1 }, 4053 /* 68ec030 access control unit, identical to 030 MMU status reg. */ 4054 { "acusr", PSR }, 4055 4056 /* Suppressed data and address registers. */ 4057 { "zd0", ZDATA0 }, 4058 { "zd1", ZDATA1 }, 4059 { "zd2", ZDATA2 }, 4060 { "zd3", ZDATA3 }, 4061 { "zd4", ZDATA4 }, 4062 { "zd5", ZDATA5 }, 4063 { "zd6", ZDATA6 }, 4064 { "zd7", ZDATA7 }, 4065 { "za0", ZADDR0 }, 4066 { "za1", ZADDR1 }, 4067 { "za2", ZADDR2 }, 4068 { "za3", ZADDR3 }, 4069 { "za4", ZADDR4 }, 4070 { "za5", ZADDR5 }, 4071 { "za6", ZADDR6 }, 4072 { "za7", ZADDR7 }, 4073 4074 /* Upper and lower data and address registers, used by macw and msacw. */ 4075 { "d0l", DATA0L }, 4076 { "d1l", DATA1L }, 4077 { "d2l", DATA2L }, 4078 { "d3l", DATA3L }, 4079 { "d4l", DATA4L }, 4080 { "d5l", DATA5L }, 4081 { "d6l", DATA6L }, 4082 { "d7l", DATA7L }, 4083 4084 { "a0l", ADDR0L }, 4085 { "a1l", ADDR1L }, 4086 { "a2l", ADDR2L }, 4087 { "a3l", ADDR3L }, 4088 { "a4l", ADDR4L }, 4089 { "a5l", ADDR5L }, 4090 { "a6l", ADDR6L }, 4091 { "a7l", ADDR7L }, 4092 4093 { "d0u", DATA0U }, 4094 { "d1u", DATA1U }, 4095 { "d2u", DATA2U }, 4096 { "d3u", DATA3U }, 4097 { "d4u", DATA4U }, 4098 { "d5u", DATA5U }, 4099 { "d6u", DATA6U }, 4100 { "d7u", DATA7U }, 4101 4102 { "a0u", ADDR0U }, 4103 { "a1u", ADDR1U }, 4104 { "a2u", ADDR2U }, 4105 { "a3u", ADDR3U }, 4106 { "a4u", ADDR4U }, 4107 { "a5u", ADDR5U }, 4108 { "a6u", ADDR6U }, 4109 { "a7u", ADDR7U }, 4110 4111 { 0, 0 } 4112 }; 4113 4114 static void 4115 init_regtable (void) 4116 { 4117 int i; 4118 for (i = 0; init_table[i].name; i++) 4119 insert_reg (init_table[i].name, init_table[i].number); 4120 } 4121 4122 void 4123 md_assemble (char *str) 4124 { 4125 const char *er; 4126 short *fromP; 4127 char *toP = NULL; 4128 int m, n = 0; 4129 char *to_beg_P; 4130 int shorts_this_frag; 4131 fixS *fixP; 4132 4133 if (!selected_cpu && !selected_arch) 4134 { 4135 /* We've not selected an architecture yet. Set the default 4136 now. We do this lazily so that an initial .cpu or .arch directive 4137 can specify. */ 4138 if (!m68k_set_cpu (TARGET_CPU, 1, 1)) 4139 as_bad (_("unrecognized default cpu `%s'"), TARGET_CPU); 4140 } 4141 if (!initialized) 4142 m68k_init_arch (); 4143 4144 /* In MRI mode, the instruction and operands are separated by a 4145 space. Anything following the operands is a comment. The label 4146 has already been removed. */ 4147 if (flag_mri) 4148 { 4149 char *s; 4150 int fields = 0; 4151 int infield = 0; 4152 int inquote = 0; 4153 4154 for (s = str; *s != '\0'; s++) 4155 { 4156 if ((*s == ' ' || *s == '\t') && ! inquote) 4157 { 4158 if (infield) 4159 { 4160 ++fields; 4161 if (fields >= 2) 4162 { 4163 *s = '\0'; 4164 break; 4165 } 4166 infield = 0; 4167 } 4168 } 4169 else 4170 { 4171 if (! infield) 4172 infield = 1; 4173 if (*s == '\'') 4174 inquote = ! inquote; 4175 } 4176 } 4177 } 4178 4179 memset (&the_ins, '\0', sizeof (the_ins)); 4180 m68k_ip (str); 4181 er = the_ins.error; 4182 if (!er) 4183 { 4184 for (n = 0; n < the_ins.numargs; n++) 4185 if (the_ins.operands[n].error) 4186 { 4187 er = the_ins.operands[n].error; 4188 break; 4189 } 4190 } 4191 if (er) 4192 { 4193 as_bad (_("%s -- statement `%s' ignored"), er, str); 4194 return; 4195 } 4196 4197 /* If there is a current label, record that it marks an instruction. */ 4198 if (current_label != NULL) 4199 { 4200 current_label->text = 1; 4201 current_label = NULL; 4202 } 4203 4204 #ifdef OBJ_ELF 4205 /* Tie dwarf2 debug info to the address at the start of the insn. */ 4206 dwarf2_emit_insn (0); 4207 #endif 4208 4209 if (the_ins.nfrag == 0) 4210 { 4211 /* No frag hacking involved; just put it out. */ 4212 toP = frag_more (2 * the_ins.numo); 4213 fromP = &the_ins.opcode[0]; 4214 for (m = the_ins.numo; m; --m) 4215 { 4216 md_number_to_chars (toP, (long) (*fromP), 2); 4217 toP += 2; 4218 fromP++; 4219 } 4220 /* Put out symbol-dependent info. */ 4221 for (m = 0; m < the_ins.nrel; m++) 4222 { 4223 switch (the_ins.reloc[m].wid) 4224 { 4225 case 'B': 4226 n = 1; 4227 break; 4228 case 'b': 4229 n = 1; 4230 break; 4231 case '3': 4232 n = 1; 4233 break; 4234 case 'w': 4235 case 'W': 4236 n = 2; 4237 break; 4238 case 'l': 4239 n = 4; 4240 break; 4241 default: 4242 as_fatal (_("Don't know how to figure width of %c in md_assemble()"), 4243 the_ins.reloc[m].wid); 4244 } 4245 4246 fixP = fix_new_exp (frag_now, 4247 ((toP - frag_now->fr_literal) 4248 - the_ins.numo * 2 + the_ins.reloc[m].n), 4249 n, 4250 &the_ins.reloc[m].exp, 4251 the_ins.reloc[m].pcrel, 4252 get_reloc_code (n, the_ins.reloc[m].pcrel, 4253 the_ins.reloc[m].pic_reloc)); 4254 fixP->fx_pcrel_adjust = the_ins.reloc[m].pcrel_fix; 4255 if (the_ins.reloc[m].wid == 'B') 4256 fixP->fx_signed = 1; 4257 } 4258 return; 4259 } 4260 4261 /* There's some frag hacking. */ 4262 { 4263 /* Calculate the max frag size. */ 4264 int wid; 4265 4266 wid = 2 * the_ins.fragb[0].fragoff; 4267 for (n = 1; n < the_ins.nfrag; n++) 4268 wid += 2 * (the_ins.numo - the_ins.fragb[n - 1].fragoff); 4269 /* frag_var part. */ 4270 wid += FRAG_VAR_SIZE; 4271 /* Make sure the whole insn fits in one chunk, in particular that 4272 the var part is attached, as we access one byte before the 4273 variable frag for byte branches. */ 4274 frag_grow (wid); 4275 } 4276 4277 for (n = 0, fromP = &the_ins.opcode[0]; n < the_ins.nfrag; n++) 4278 { 4279 int wid; 4280 4281 if (n == 0) 4282 wid = 2 * the_ins.fragb[n].fragoff; 4283 else 4284 wid = 2 * (the_ins.numo - the_ins.fragb[n - 1].fragoff); 4285 toP = frag_more (wid); 4286 to_beg_P = toP; 4287 shorts_this_frag = 0; 4288 for (m = wid / 2; m; --m) 4289 { 4290 md_number_to_chars (toP, (long) (*fromP), 2); 4291 toP += 2; 4292 fromP++; 4293 shorts_this_frag++; 4294 } 4295 for (m = 0; m < the_ins.nrel; m++) 4296 { 4297 if ((the_ins.reloc[m].n) >= 2 * shorts_this_frag) 4298 { 4299 the_ins.reloc[m].n -= 2 * shorts_this_frag; 4300 break; 4301 } 4302 wid = the_ins.reloc[m].wid; 4303 if (wid == 0) 4304 continue; 4305 the_ins.reloc[m].wid = 0; 4306 wid = (wid == 'b') ? 1 : (wid == 'w') ? 2 : (wid == 'l') ? 4 : 4000; 4307 4308 fixP = fix_new_exp (frag_now, 4309 ((toP - frag_now->fr_literal) 4310 - the_ins.numo * 2 + the_ins.reloc[m].n), 4311 wid, 4312 &the_ins.reloc[m].exp, 4313 the_ins.reloc[m].pcrel, 4314 get_reloc_code (wid, the_ins.reloc[m].pcrel, 4315 the_ins.reloc[m].pic_reloc)); 4316 fixP->fx_pcrel_adjust = the_ins.reloc[m].pcrel_fix; 4317 } 4318 (void) frag_var (rs_machine_dependent, FRAG_VAR_SIZE, 0, 4319 (relax_substateT) (the_ins.fragb[n].fragty), 4320 the_ins.fragb[n].fadd, the_ins.fragb[n].foff, to_beg_P); 4321 } 4322 n = (the_ins.numo - the_ins.fragb[n - 1].fragoff); 4323 shorts_this_frag = 0; 4324 if (n) 4325 { 4326 toP = frag_more (n * 2); 4327 while (n--) 4328 { 4329 md_number_to_chars (toP, (long) (*fromP), 2); 4330 toP += 2; 4331 fromP++; 4332 shorts_this_frag++; 4333 } 4334 } 4335 for (m = 0; m < the_ins.nrel; m++) 4336 { 4337 int wid; 4338 4339 wid = the_ins.reloc[m].wid; 4340 if (wid == 0) 4341 continue; 4342 the_ins.reloc[m].wid = 0; 4343 wid = (wid == 'b') ? 1 : (wid == 'w') ? 2 : (wid == 'l') ? 4 : 4000; 4344 4345 fixP = fix_new_exp (frag_now, 4346 ((the_ins.reloc[m].n + toP - frag_now->fr_literal) 4347 - shorts_this_frag * 2), 4348 wid, 4349 &the_ins.reloc[m].exp, 4350 the_ins.reloc[m].pcrel, 4351 get_reloc_code (wid, the_ins.reloc[m].pcrel, 4352 the_ins.reloc[m].pic_reloc)); 4353 fixP->fx_pcrel_adjust = the_ins.reloc[m].pcrel_fix; 4354 } 4355 } 4356 4357 /* Comparison function used by qsort to rank the opcode entries by name. */ 4358 4359 static int 4360 m68k_compare_opcode (const void * v1, const void * v2) 4361 { 4362 struct m68k_opcode * op1, * op2; 4363 int ret; 4364 4365 if (v1 == v2) 4366 return 0; 4367 4368 op1 = *(struct m68k_opcode **) v1; 4369 op2 = *(struct m68k_opcode **) v2; 4370 4371 /* Compare the two names. If different, return the comparison. 4372 If the same, return the order they are in the opcode table. */ 4373 ret = strcmp (op1->name, op2->name); 4374 if (ret) 4375 return ret; 4376 if (op1 < op2) 4377 return -1; 4378 return 1; 4379 } 4380 4381 void 4382 md_begin (void) 4383 { 4384 const struct m68k_opcode *ins; 4385 struct m68k_incant *hack, *slak; 4386 const char *retval = 0; /* Empty string, or error msg text. */ 4387 int i; 4388 4389 /* Set up hash tables with 68000 instructions. 4390 similar to what the vax assembler does. */ 4391 /* RMS claims the thing to do is take the m68k-opcode.h table, and make 4392 a copy of it at runtime, adding in the information we want but isn't 4393 there. I think it'd be better to have an awk script hack the table 4394 at compile time. Or even just xstr the table and use it as-is. But 4395 my lord ghod hath spoken, so we do it this way. Excuse the ugly var 4396 names. */ 4397 4398 if (flag_mri) 4399 { 4400 flag_reg_prefix_optional = 1; 4401 m68k_abspcadd = 1; 4402 if (! m68k_rel32_from_cmdline) 4403 m68k_rel32 = 0; 4404 } 4405 4406 /* First sort the opcode table into alphabetical order to seperate 4407 the order that the assembler wants to see the opcodes from the 4408 order that the disassembler wants to see them. */ 4409 m68k_sorted_opcodes = xmalloc (m68k_numopcodes * sizeof (* m68k_sorted_opcodes)); 4410 if (!m68k_sorted_opcodes) 4411 as_fatal (_("Internal Error: Can't allocate m68k_sorted_opcodes of size %d"), 4412 m68k_numopcodes * ((int) sizeof (* m68k_sorted_opcodes))); 4413 4414 for (i = m68k_numopcodes; i--;) 4415 m68k_sorted_opcodes[i] = m68k_opcodes + i; 4416 4417 qsort (m68k_sorted_opcodes, m68k_numopcodes, 4418 sizeof (m68k_sorted_opcodes[0]), m68k_compare_opcode); 4419 4420 op_hash = hash_new (); 4421 4422 obstack_begin (&robyn, 4000); 4423 for (i = 0; i < m68k_numopcodes; i++) 4424 { 4425 hack = slak = (struct m68k_incant *) obstack_alloc (&robyn, sizeof (struct m68k_incant)); 4426 do 4427 { 4428 ins = m68k_sorted_opcodes[i]; 4429 4430 /* We must enter all insns into the table, because .arch and 4431 .cpu directives can change things. */ 4432 slak->m_operands = ins->args; 4433 slak->m_arch = ins->arch; 4434 slak->m_opcode = ins->opcode; 4435 4436 /* In most cases we can determine the number of opcode words 4437 by checking the second word of the mask. Unfortunately 4438 some instructions have 2 opcode words, but no fixed bits 4439 in the second word. A leading dot in the operands 4440 string also indicates 2 opcodes. */ 4441 if (*slak->m_operands == '.') 4442 { 4443 slak->m_operands++; 4444 slak->m_codenum = 2; 4445 } 4446 else if (ins->match & 0xffffL) 4447 slak->m_codenum = 2; 4448 else 4449 slak->m_codenum = 1; 4450 slak->m_opnum = strlen (slak->m_operands) / 2; 4451 4452 if (i + 1 != m68k_numopcodes 4453 && !strcmp (ins->name, m68k_sorted_opcodes[i + 1]->name)) 4454 { 4455 slak->m_next = obstack_alloc (&robyn, sizeof (struct m68k_incant)); 4456 i++; 4457 } 4458 else 4459 slak->m_next = 0; 4460 slak = slak->m_next; 4461 } 4462 while (slak); 4463 4464 retval = hash_insert (op_hash, ins->name, (char *) hack); 4465 if (retval) 4466 as_fatal (_("Internal Error: Can't hash %s: %s"), ins->name, retval); 4467 } 4468 4469 for (i = 0; i < m68k_numaliases; i++) 4470 { 4471 const char *name = m68k_opcode_aliases[i].primary; 4472 const char *alias = m68k_opcode_aliases[i].alias; 4473 void *val = hash_find (op_hash, name); 4474 4475 if (!val) 4476 as_fatal (_("Internal Error: Can't find %s in hash table"), name); 4477 retval = hash_insert (op_hash, alias, val); 4478 if (retval) 4479 as_fatal (_("Internal Error: Can't hash %s: %s"), alias, retval); 4480 } 4481 4482 /* In MRI mode, all unsized branches are variable sized. Normally, 4483 they are word sized. */ 4484 if (flag_mri) 4485 { 4486 static struct m68k_opcode_alias mri_aliases[] = 4487 { 4488 { "bhi", "jhi", }, 4489 { "bls", "jls", }, 4490 { "bcc", "jcc", }, 4491 { "bcs", "jcs", }, 4492 { "bne", "jne", }, 4493 { "beq", "jeq", }, 4494 { "bvc", "jvc", }, 4495 { "bvs", "jvs", }, 4496 { "bpl", "jpl", }, 4497 { "bmi", "jmi", }, 4498 { "bge", "jge", }, 4499 { "blt", "jlt", }, 4500 { "bgt", "jgt", }, 4501 { "ble", "jle", }, 4502 { "bra", "jra", }, 4503 { "bsr", "jbsr", }, 4504 }; 4505 4506 for (i = 0; 4507 i < (int) (sizeof mri_aliases / sizeof mri_aliases[0]); 4508 i++) 4509 { 4510 const char *name = mri_aliases[i].primary; 4511 const char *alias = mri_aliases[i].alias; 4512 void *val = hash_find (op_hash, name); 4513 4514 if (!val) 4515 as_fatal (_("Internal Error: Can't find %s in hash table"), name); 4516 retval = hash_jam (op_hash, alias, val); 4517 if (retval) 4518 as_fatal (_("Internal Error: Can't hash %s: %s"), alias, retval); 4519 } 4520 } 4521 4522 for (i = 0; i < (int) sizeof (notend_table); i++) 4523 { 4524 notend_table[i] = 0; 4525 alt_notend_table[i] = 0; 4526 } 4527 4528 notend_table[','] = 1; 4529 notend_table['{'] = 1; 4530 notend_table['}'] = 1; 4531 alt_notend_table['a'] = 1; 4532 alt_notend_table['A'] = 1; 4533 alt_notend_table['d'] = 1; 4534 alt_notend_table['D'] = 1; 4535 alt_notend_table['#'] = 1; 4536 alt_notend_table['&'] = 1; 4537 alt_notend_table['f'] = 1; 4538 alt_notend_table['F'] = 1; 4539 #ifdef REGISTER_PREFIX 4540 alt_notend_table[REGISTER_PREFIX] = 1; 4541 #endif 4542 4543 /* We need to put '(' in alt_notend_table to handle 4544 cas2 %d0:%d2,%d3:%d4,(%a0):(%a1) */ 4545 alt_notend_table['('] = 1; 4546 4547 /* We need to put '@' in alt_notend_table to handle 4548 cas2 %d0:%d2,%d3:%d4,@(%d0):@(%d1) */ 4549 alt_notend_table['@'] = 1; 4550 4551 /* We need to put digits in alt_notend_table to handle 4552 bfextu %d0{24:1},%d0 */ 4553 alt_notend_table['0'] = 1; 4554 alt_notend_table['1'] = 1; 4555 alt_notend_table['2'] = 1; 4556 alt_notend_table['3'] = 1; 4557 alt_notend_table['4'] = 1; 4558 alt_notend_table['5'] = 1; 4559 alt_notend_table['6'] = 1; 4560 alt_notend_table['7'] = 1; 4561 alt_notend_table['8'] = 1; 4562 alt_notend_table['9'] = 1; 4563 4564 #ifndef MIT_SYNTAX_ONLY 4565 /* Insert pseudo ops, these have to go into the opcode table since 4566 gas expects pseudo ops to start with a dot. */ 4567 { 4568 int n = 0; 4569 4570 while (mote_pseudo_table[n].poc_name) 4571 { 4572 hack = obstack_alloc (&robyn, sizeof (struct m68k_incant)); 4573 hash_insert (op_hash, 4574 mote_pseudo_table[n].poc_name, (char *) hack); 4575 hack->m_operands = 0; 4576 hack->m_opnum = n; 4577 n++; 4578 } 4579 } 4580 #endif 4581 4582 init_regtable (); 4583 4584 #ifdef OBJ_ELF 4585 record_alignment (text_section, 2); 4586 record_alignment (data_section, 2); 4587 record_alignment (bss_section, 2); 4588 #endif 4589 } 4590 4591 4592 /* This is called when a label is defined. */ 4593 4594 void 4595 m68k_frob_label (symbolS *sym) 4596 { 4597 struct label_line *n; 4598 4599 n = (struct label_line *) xmalloc (sizeof *n); 4600 n->next = labels; 4601 n->label = sym; 4602 as_where (&n->file, &n->line); 4603 n->text = 0; 4604 labels = n; 4605 current_label = n; 4606 4607 #ifdef OBJ_ELF 4608 dwarf2_emit_label (sym); 4609 #endif 4610 } 4611 4612 /* This is called when a value that is not an instruction is emitted. */ 4613 4614 void 4615 m68k_flush_pending_output (void) 4616 { 4617 current_label = NULL; 4618 } 4619 4620 /* This is called at the end of the assembly, when the final value of 4621 the label is known. We warn if this is a text symbol aligned at an 4622 odd location. */ 4623 4624 void 4625 m68k_frob_symbol (symbolS *sym) 4626 { 4627 if (S_GET_SEGMENT (sym) == reg_section 4628 && (int) S_GET_VALUE (sym) < 0) 4629 { 4630 S_SET_SEGMENT (sym, absolute_section); 4631 S_SET_VALUE (sym, ~(int)S_GET_VALUE (sym)); 4632 } 4633 else if ((S_GET_VALUE (sym) & 1) != 0) 4634 { 4635 struct label_line *l; 4636 4637 for (l = labels; l != NULL; l = l->next) 4638 { 4639 if (l->label == sym) 4640 { 4641 if (l->text) 4642 as_warn_where (l->file, l->line, 4643 _("text label `%s' aligned to odd boundary"), 4644 S_GET_NAME (sym)); 4645 break; 4646 } 4647 } 4648 } 4649 } 4650 4651 /* This is called if we go in or out of MRI mode because of the .mri 4652 pseudo-op. */ 4653 4654 void 4655 m68k_mri_mode_change (int on) 4656 { 4657 if (on) 4658 { 4659 if (! flag_reg_prefix_optional) 4660 { 4661 flag_reg_prefix_optional = 1; 4662 #ifdef REGISTER_PREFIX 4663 init_regtable (); 4664 #endif 4665 } 4666 m68k_abspcadd = 1; 4667 if (! m68k_rel32_from_cmdline) 4668 m68k_rel32 = 0; 4669 } 4670 else 4671 { 4672 if (! reg_prefix_optional_seen) 4673 { 4674 #ifdef REGISTER_PREFIX_OPTIONAL 4675 flag_reg_prefix_optional = REGISTER_PREFIX_OPTIONAL; 4676 #else 4677 flag_reg_prefix_optional = 0; 4678 #endif 4679 #ifdef REGISTER_PREFIX 4680 init_regtable (); 4681 #endif 4682 } 4683 m68k_abspcadd = 0; 4684 if (! m68k_rel32_from_cmdline) 4685 m68k_rel32 = 1; 4686 } 4687 } 4688 4689 char * 4690 md_atof (int type, char *litP, int *sizeP) 4691 { 4692 return ieee_md_atof (type, litP, sizeP, TRUE); 4693 } 4694 4695 void 4696 md_number_to_chars (char *buf, valueT val, int n) 4697 { 4698 number_to_chars_bigendian (buf, val, n); 4699 } 4700 4701 void 4702 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED) 4703 { 4704 offsetT val = *valP; 4705 addressT upper_limit; 4706 offsetT lower_limit; 4707 4708 /* This is unnecessary but it convinces the native rs6000 compiler 4709 to generate the code we want. */ 4710 char *buf = fixP->fx_frag->fr_literal; 4711 buf += fixP->fx_where; 4712 /* End ibm compiler workaround. */ 4713 4714 val = SEXT (val); 4715 4716 if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0) 4717 fixP->fx_done = 1; 4718 4719 #ifdef OBJ_ELF 4720 if (fixP->fx_addsy) 4721 { 4722 memset (buf, 0, fixP->fx_size); 4723 fixP->fx_addnumber = val; /* Remember value for emit_reloc. */ 4724 4725 if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT 4726 && !S_IS_DEFINED (fixP->fx_addsy) 4727 && !S_IS_WEAK (fixP->fx_addsy)) 4728 S_SET_WEAK (fixP->fx_addsy); 4729 return; 4730 } 4731 #elif defined(OBJ_AOUT) 4732 /* PR gas/3041 Do not fix frags referencing a weak symbol. */ 4733 if (fixP->fx_addsy && S_IS_WEAK (fixP->fx_addsy)) 4734 { 4735 memset (buf, 0, fixP->fx_size); 4736 fixP->fx_addnumber = val; /* Remember value for emit_reloc. */ 4737 return; 4738 } 4739 #endif 4740 4741 if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT 4742 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY) 4743 return; 4744 4745 switch (fixP->fx_size) 4746 { 4747 /* The cast to offsetT below are necessary to make code 4748 correct for machines where ints are smaller than offsetT. */ 4749 case 1: 4750 *buf++ = val; 4751 upper_limit = 0x7f; 4752 lower_limit = - (offsetT) 0x80; 4753 break; 4754 case 2: 4755 *buf++ = (val >> 8); 4756 *buf++ = val; 4757 upper_limit = 0x7fff; 4758 lower_limit = - (offsetT) 0x8000; 4759 break; 4760 case 4: 4761 *buf++ = (val >> 24); 4762 *buf++ = (val >> 16); 4763 *buf++ = (val >> 8); 4764 *buf++ = val; 4765 upper_limit = 0x7fffffff; 4766 lower_limit = - (offsetT) 0x7fffffff - 1; /* Avoid constant overflow. */ 4767 break; 4768 default: 4769 BAD_CASE (fixP->fx_size); 4770 } 4771 4772 /* Fix up a negative reloc. */ 4773 if (fixP->fx_addsy == NULL && fixP->fx_subsy != NULL) 4774 { 4775 fixP->fx_addsy = fixP->fx_subsy; 4776 fixP->fx_subsy = NULL; 4777 fixP->fx_tcbit = 1; 4778 } 4779 4780 /* For non-pc-relative values, it's conceivable we might get something 4781 like "0xff" for a byte field. So extend the upper part of the range 4782 to accept such numbers. We arbitrarily disallow "-0xff" or "0xff+0xff", 4783 so that we can do any range checking at all. */ 4784 if (! fixP->fx_pcrel && ! fixP->fx_signed) 4785 upper_limit = upper_limit * 2 + 1; 4786 4787 if ((addressT) val > upper_limit 4788 && (val > 0 || val < lower_limit)) 4789 as_bad_where (fixP->fx_file, fixP->fx_line, 4790 _("value %ld out of range"), (long)val); 4791 4792 /* A one byte PC-relative reloc means a short branch. We can't use 4793 a short branch with a value of 0 or -1, because those indicate 4794 different opcodes (branches with longer offsets). fixup_segment 4795 in write.c may have clobbered fx_pcrel, so we need to examine the 4796 reloc type. */ 4797 if ((fixP->fx_pcrel 4798 || fixP->fx_r_type == BFD_RELOC_8_PCREL) 4799 && fixP->fx_size == 1 4800 && (fixP->fx_addsy == NULL 4801 || S_IS_DEFINED (fixP->fx_addsy)) 4802 && (val == 0 || val == -1)) 4803 as_bad_where (fixP->fx_file, fixP->fx_line, 4804 _("invalid byte branch offset")); 4805 } 4806 4807 /* *fragP has been relaxed to its final size, and now needs to have 4808 the bytes inside it modified to conform to the new size There is UGLY 4809 MAGIC here. .. 4810 */ 4811 static void 4812 md_convert_frag_1 (fragS *fragP) 4813 { 4814 long disp; 4815 fixS *fixP = NULL; 4816 4817 /* Address in object code of the displacement. */ 4818 register int object_address = fragP->fr_fix + fragP->fr_address; 4819 4820 /* Address in gas core of the place to store the displacement. */ 4821 /* This convinces the native rs6000 compiler to generate the code we 4822 want. */ 4823 register char *buffer_address = fragP->fr_literal; 4824 buffer_address += fragP->fr_fix; 4825 /* End ibm compiler workaround. */ 4826 4827 /* The displacement of the address, from current location. */ 4828 disp = fragP->fr_symbol ? S_GET_VALUE (fragP->fr_symbol) : 0; 4829 disp = (disp + fragP->fr_offset) - object_address; 4830 4831 switch (fragP->fr_subtype) 4832 { 4833 case TAB (BRANCHBWL, BYTE): 4834 case TAB (BRABSJUNC, BYTE): 4835 case TAB (BRABSJCOND, BYTE): 4836 case TAB (BRANCHBW, BYTE): 4837 case TAB (BRANCHBWPL, BYTE): 4838 know (issbyte (disp)); 4839 if (disp == 0) 4840 as_bad_where (fragP->fr_file, fragP->fr_line, 4841 _("short branch with zero offset: use :w")); 4842 fixP = fix_new (fragP, fragP->fr_fix - 1, 1, fragP->fr_symbol, 4843 fragP->fr_offset, 1, RELAX_RELOC_PC8); 4844 fixP->fx_pcrel_adjust = -1; 4845 break; 4846 case TAB (BRANCHBWL, SHORT): 4847 case TAB (BRABSJUNC, SHORT): 4848 case TAB (BRABSJCOND, SHORT): 4849 case TAB (BRANCHBW, SHORT): 4850 case TAB (BRANCHBWPL, SHORT): 4851 fragP->fr_opcode[1] = 0x00; 4852 fixP = fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, 4853 fragP->fr_offset, 1, RELAX_RELOC_PC16); 4854 fragP->fr_fix += 2; 4855 break; 4856 case TAB (BRANCHBWL, LONG): 4857 fragP->fr_opcode[1] = (char) 0xFF; 4858 fixP = fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, 4859 fragP->fr_offset, 1, RELAX_RELOC_PC32); 4860 fragP->fr_fix += 4; 4861 break; 4862 case TAB (BRANCHBWPL, LONG): 4863 /* Here we are converting an unconditional branch into a pair of 4864 conditional branches, in order to get the range. */ 4865 fragP->fr_opcode[0] = 0x66; /* bne */ 4866 fragP->fr_opcode[1] = 0xFF; 4867 fixP = fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, 4868 fragP->fr_offset, 1, RELAX_RELOC_PC32); 4869 fixP->fx_file = fragP->fr_file; 4870 fixP->fx_line = fragP->fr_line; 4871 fragP->fr_fix += 4; /* Skip first offset */ 4872 buffer_address += 4; 4873 *buffer_address++ = 0x67; /* beq */ 4874 *buffer_address++ = 0xff; 4875 fragP->fr_fix += 2; /* Skip second branch opcode */ 4876 fixP = fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, 4877 fragP->fr_offset, 1, RELAX_RELOC_PC32); 4878 fragP->fr_fix += 4; 4879 break; 4880 case TAB (BRABSJUNC, LONG): 4881 if (fragP->fr_opcode[0] == 0x61) /* jbsr */ 4882 { 4883 if (flag_keep_pcrel) 4884 as_bad_where (fragP->fr_file, fragP->fr_line, 4885 _("Conversion of PC relative BSR to absolute JSR")); 4886 fragP->fr_opcode[0] = 0x4E; 4887 fragP->fr_opcode[1] = (char) 0xB9; /* JSR with ABSL LONG operand. */ 4888 fixP = fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, 4889 fragP->fr_offset, 0, RELAX_RELOC_ABS32); 4890 fragP->fr_fix += 4; 4891 } 4892 else if (fragP->fr_opcode[0] == 0x60) /* jbra */ 4893 { 4894 if (flag_keep_pcrel) 4895 as_bad_where (fragP->fr_file, fragP->fr_line, 4896 _("Conversion of PC relative branch to absolute jump")); 4897 fragP->fr_opcode[0] = 0x4E; 4898 fragP->fr_opcode[1] = (char) 0xF9; /* JMP with ABSL LONG operand. */ 4899 fixP = fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, 4900 fragP->fr_offset, 0, RELAX_RELOC_ABS32); 4901 fragP->fr_fix += 4; 4902 } 4903 else 4904 { 4905 /* This cannot happen, because jbsr and jbra are the only two 4906 unconditional branches. */ 4907 abort (); 4908 } 4909 break; 4910 case TAB (BRABSJCOND, LONG): 4911 if (flag_keep_pcrel) 4912 as_bad_where (fragP->fr_file, fragP->fr_line, 4913 _("Conversion of PC relative conditional branch to absolute jump")); 4914 4915 /* Only Bcc 68000 instructions can come here 4916 Change bcc into b!cc/jmp absl long. */ 4917 fragP->fr_opcode[0] ^= 0x01; /* Invert bcc. */ 4918 fragP->fr_opcode[1] = 0x06; /* Branch offset = 6. */ 4919 4920 /* JF: these used to be fr_opcode[2,3], but they may be in a 4921 different frag, in which case referring to them is a no-no. 4922 Only fr_opcode[0,1] are guaranteed to work. */ 4923 *buffer_address++ = 0x4e; /* put in jmp long (0x4ef9) */ 4924 *buffer_address++ = (char) 0xf9; 4925 fragP->fr_fix += 2; /* Account for jmp instruction. */ 4926 fixP = fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, 4927 fragP->fr_offset, 0, RELAX_RELOC_ABS32); 4928 fragP->fr_fix += 4; 4929 break; 4930 case TAB (FBRANCH, SHORT): 4931 know ((fragP->fr_opcode[1] & 0x40) == 0); 4932 fixP = fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, 4933 fragP->fr_offset, 1, RELAX_RELOC_PC16); 4934 fragP->fr_fix += 2; 4935 break; 4936 case TAB (FBRANCH, LONG): 4937 fragP->fr_opcode[1] |= 0x40; /* Turn on LONG bit. */ 4938 fixP = fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, 4939 fragP->fr_offset, 1, RELAX_RELOC_PC32); 4940 fragP->fr_fix += 4; 4941 break; 4942 case TAB (DBCCLBR, SHORT): 4943 case TAB (DBCCABSJ, SHORT): 4944 fixP = fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, 4945 fragP->fr_offset, 1, RELAX_RELOC_PC16); 4946 fragP->fr_fix += 2; 4947 break; 4948 case TAB (DBCCLBR, LONG): 4949 /* Only DBcc instructions can come here. 4950 Change dbcc into dbcc/bral. 4951 JF: these used to be fr_opcode[2-7], but that's wrong. */ 4952 if (flag_keep_pcrel) 4953 as_bad_where (fragP->fr_file, fragP->fr_line, 4954 _("Conversion of DBcc to absolute jump")); 4955 4956 *buffer_address++ = 0x00; /* Branch offset = 4. */ 4957 *buffer_address++ = 0x04; 4958 *buffer_address++ = 0x60; /* Put in bra pc+6. */ 4959 *buffer_address++ = 0x06; 4960 *buffer_address++ = 0x60; /* Put in bral (0x60ff). */ 4961 *buffer_address++ = (char) 0xff; 4962 4963 fragP->fr_fix += 6; /* Account for bra/jmp instructions. */ 4964 fixP = fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, 4965 fragP->fr_offset, 1, RELAX_RELOC_PC32); 4966 fragP->fr_fix += 4; 4967 break; 4968 case TAB (DBCCABSJ, LONG): 4969 /* Only DBcc instructions can come here. 4970 Change dbcc into dbcc/jmp. 4971 JF: these used to be fr_opcode[2-7], but that's wrong. */ 4972 if (flag_keep_pcrel) 4973 as_bad_where (fragP->fr_file, fragP->fr_line, 4974 _("Conversion of PC relative conditional branch to absolute jump")); 4975 4976 *buffer_address++ = 0x00; /* Branch offset = 4. */ 4977 *buffer_address++ = 0x04; 4978 *buffer_address++ = 0x60; /* Put in bra pc + 6. */ 4979 *buffer_address++ = 0x06; 4980 *buffer_address++ = 0x4e; /* Put in jmp long (0x4ef9). */ 4981 *buffer_address++ = (char) 0xf9; 4982 4983 fragP->fr_fix += 6; /* Account for bra/jmp instructions. */ 4984 fixP = fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, 4985 fragP->fr_offset, 0, RELAX_RELOC_ABS32); 4986 fragP->fr_fix += 4; 4987 break; 4988 case TAB (PCREL1632, SHORT): 4989 fragP->fr_opcode[1] &= ~0x3F; 4990 fragP->fr_opcode[1] |= 0x3A; /* 072 - mode 7.2 */ 4991 fixP = fix_new (fragP, (int) (fragP->fr_fix), 2, fragP->fr_symbol, 4992 fragP->fr_offset, 1, RELAX_RELOC_PC16); 4993 fragP->fr_fix += 2; 4994 break; 4995 case TAB (PCREL1632, LONG): 4996 /* Already set to mode 7.3; this indicates: PC indirect with 4997 suppressed index, 32-bit displacement. */ 4998 *buffer_address++ = 0x01; 4999 *buffer_address++ = 0x70; 5000 fragP->fr_fix += 2; 5001 fixP = fix_new (fragP, (int) (fragP->fr_fix), 4, fragP->fr_symbol, 5002 fragP->fr_offset, 1, RELAX_RELOC_PC32); 5003 fixP->fx_pcrel_adjust = 2; 5004 fragP->fr_fix += 4; 5005 break; 5006 case TAB (PCINDEX, BYTE): 5007 assert (fragP->fr_fix >= 2); 5008 buffer_address[-2] &= ~1; 5009 fixP = fix_new (fragP, fragP->fr_fix - 1, 1, fragP->fr_symbol, 5010 fragP->fr_offset, 1, RELAX_RELOC_PC8); 5011 fixP->fx_pcrel_adjust = 1; 5012 break; 5013 case TAB (PCINDEX, SHORT): 5014 assert (fragP->fr_fix >= 2); 5015 buffer_address[-2] |= 0x1; 5016 buffer_address[-1] = 0x20; 5017 fixP = fix_new (fragP, (int) (fragP->fr_fix), 2, fragP->fr_symbol, 5018 fragP->fr_offset, 1, RELAX_RELOC_PC16); 5019 fixP->fx_pcrel_adjust = 2; 5020 fragP->fr_fix += 2; 5021 break; 5022 case TAB (PCINDEX, LONG): 5023 assert (fragP->fr_fix >= 2); 5024 buffer_address[-2] |= 0x1; 5025 buffer_address[-1] = 0x30; 5026 fixP = fix_new (fragP, (int) (fragP->fr_fix), 4, fragP->fr_symbol, 5027 fragP->fr_offset, 1, RELAX_RELOC_PC32); 5028 fixP->fx_pcrel_adjust = 2; 5029 fragP->fr_fix += 4; 5030 break; 5031 case TAB (ABSTOPCREL, SHORT): 5032 fixP = fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, 5033 fragP->fr_offset, 1, RELAX_RELOC_PC16); 5034 fragP->fr_fix += 2; 5035 break; 5036 case TAB (ABSTOPCREL, LONG): 5037 if (flag_keep_pcrel) 5038 as_bad_where (fragP->fr_file, fragP->fr_line, 5039 _("Conversion of PC relative displacement to absolute")); 5040 /* The thing to do here is force it to ABSOLUTE LONG, since 5041 ABSTOPCREL is really trying to shorten an ABSOLUTE address anyway. */ 5042 if ((fragP->fr_opcode[1] & 0x3F) != 0x3A) 5043 abort (); 5044 fragP->fr_opcode[1] &= ~0x3F; 5045 fragP->fr_opcode[1] |= 0x39; /* Mode 7.1 */ 5046 fixP = fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, 5047 fragP->fr_offset, 0, RELAX_RELOC_ABS32); 5048 fragP->fr_fix += 4; 5049 break; 5050 } 5051 if (fixP) 5052 { 5053 fixP->fx_file = fragP->fr_file; 5054 fixP->fx_line = fragP->fr_line; 5055 } 5056 } 5057 5058 void 5059 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, 5060 segT sec ATTRIBUTE_UNUSED, 5061 fragS *fragP) 5062 { 5063 md_convert_frag_1 (fragP); 5064 } 5065 5066 /* Force truly undefined symbols to their maximum size, and generally set up 5067 the frag list to be relaxed 5068 */ 5069 int 5070 md_estimate_size_before_relax (fragS *fragP, segT segment) 5071 { 5072 /* Handle SZ_UNDEF first, it can be changed to BYTE or SHORT. */ 5073 switch (fragP->fr_subtype) 5074 { 5075 case TAB (BRANCHBWL, SZ_UNDEF): 5076 case TAB (BRANCHBWPL, SZ_UNDEF): 5077 case TAB (BRABSJUNC, SZ_UNDEF): 5078 case TAB (BRABSJCOND, SZ_UNDEF): 5079 { 5080 if (S_GET_SEGMENT (fragP->fr_symbol) == segment 5081 && relaxable_symbol (fragP->fr_symbol)) 5082 { 5083 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), BYTE); 5084 } 5085 else if (flag_short_refs) 5086 { 5087 /* Symbol is undefined and we want short ref. */ 5088 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT); 5089 } 5090 else 5091 { 5092 /* Symbol is still undefined. Make it LONG. */ 5093 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), LONG); 5094 } 5095 break; 5096 } 5097 5098 case TAB (BRANCHBW, SZ_UNDEF): 5099 { 5100 if (S_GET_SEGMENT (fragP->fr_symbol) == segment 5101 && relaxable_symbol (fragP->fr_symbol)) 5102 { 5103 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), BYTE); 5104 } 5105 else 5106 { 5107 /* Symbol is undefined and we don't have long branches. */ 5108 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT); 5109 } 5110 break; 5111 } 5112 5113 case TAB (FBRANCH, SZ_UNDEF): 5114 case TAB (DBCCLBR, SZ_UNDEF): 5115 case TAB (DBCCABSJ, SZ_UNDEF): 5116 case TAB (PCREL1632, SZ_UNDEF): 5117 { 5118 if ((S_GET_SEGMENT (fragP->fr_symbol) == segment 5119 && relaxable_symbol (fragP->fr_symbol)) 5120 || flag_short_refs) 5121 { 5122 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT); 5123 } 5124 else 5125 { 5126 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), LONG); 5127 } 5128 break; 5129 } 5130 5131 case TAB (PCINDEX, SZ_UNDEF): 5132 if ((S_GET_SEGMENT (fragP->fr_symbol) == segment 5133 && relaxable_symbol (fragP->fr_symbol))) 5134 { 5135 fragP->fr_subtype = TAB (PCINDEX, BYTE); 5136 } 5137 else 5138 { 5139 fragP->fr_subtype = TAB (PCINDEX, LONG); 5140 } 5141 break; 5142 5143 case TAB (ABSTOPCREL, SZ_UNDEF): 5144 { 5145 if ((S_GET_SEGMENT (fragP->fr_symbol) == segment 5146 && relaxable_symbol (fragP->fr_symbol))) 5147 { 5148 fragP->fr_subtype = TAB (ABSTOPCREL, SHORT); 5149 } 5150 else 5151 { 5152 fragP->fr_subtype = TAB (ABSTOPCREL, LONG); 5153 } 5154 break; 5155 } 5156 5157 default: 5158 break; 5159 } 5160 5161 /* Now that SZ_UNDEF are taken care of, check others. */ 5162 switch (fragP->fr_subtype) 5163 { 5164 case TAB (BRANCHBWL, BYTE): 5165 case TAB (BRABSJUNC, BYTE): 5166 case TAB (BRABSJCOND, BYTE): 5167 case TAB (BRANCHBW, BYTE): 5168 /* We can't do a short jump to the next instruction, so in that 5169 case we force word mode. If the symbol is at the start of a 5170 frag, and it is the next frag with any data in it (usually 5171 this is just the next frag, but assembler listings may 5172 introduce empty frags), we must use word mode. */ 5173 if (fragP->fr_symbol) 5174 { 5175 fragS *sym_frag; 5176 5177 sym_frag = symbol_get_frag (fragP->fr_symbol); 5178 if (S_GET_VALUE (fragP->fr_symbol) == sym_frag->fr_address) 5179 { 5180 fragS *l; 5181 5182 for (l = fragP->fr_next; l && l != sym_frag; l = l->fr_next) 5183 if (l->fr_fix != 0) 5184 break; 5185 if (l == sym_frag) 5186 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT); 5187 } 5188 } 5189 break; 5190 default: 5191 break; 5192 } 5193 return md_relax_table[fragP->fr_subtype].rlx_length; 5194 } 5195 5196 #if defined(OBJ_AOUT) | defined(OBJ_BOUT) 5197 /* the bit-field entries in the relocation_info struct plays hell 5198 with the byte-order problems of cross-assembly. So as a hack, 5199 I added this mach. dependent ri twiddler. Ugly, but it gets 5200 you there. -KWK */ 5201 /* on m68k: first 4 bytes are normal unsigned long, next three bytes 5202 are symbolnum, most sig. byte first. Last byte is broken up with 5203 bit 7 as pcrel, bits 6 & 5 as length, bit 4 as pcrel, and the lower 5204 nibble as nuthin. (on Sun 3 at least) */ 5205 /* Translate the internal relocation information into target-specific 5206 format. */ 5207 #ifdef comment 5208 void 5209 md_ri_to_chars (char *the_bytes, struct reloc_info_generic *ri) 5210 { 5211 /* This is easy. */ 5212 md_number_to_chars (the_bytes, ri->r_address, 4); 5213 /* Now the fun stuff. */ 5214 the_bytes[4] = (ri->r_symbolnum >> 16) & 0x0ff; 5215 the_bytes[5] = (ri->r_symbolnum >> 8) & 0x0ff; 5216 the_bytes[6] = ri->r_symbolnum & 0x0ff; 5217 the_bytes[7] = (((ri->r_pcrel << 7) & 0x80) 5218 | ((ri->r_length << 5) & 0x60) 5219 | ((ri->r_extern << 4) & 0x10)); 5220 } 5221 5222 #endif 5223 5224 #endif /* OBJ_AOUT or OBJ_BOUT */ 5225 5226 #ifndef WORKING_DOT_WORD 5227 int md_short_jump_size = 4; 5228 int md_long_jump_size = 6; 5229 5230 void 5231 md_create_short_jump (char *ptr, addressT from_addr, addressT to_addr, 5232 fragS *frag ATTRIBUTE_UNUSED, 5233 symbolS *to_symbol ATTRIBUTE_UNUSED) 5234 { 5235 valueT offset; 5236 5237 offset = to_addr - (from_addr + 2); 5238 5239 md_number_to_chars (ptr, (valueT) 0x6000, 2); 5240 md_number_to_chars (ptr + 2, (valueT) offset, 2); 5241 } 5242 5243 void 5244 md_create_long_jump (char *ptr, addressT from_addr, addressT to_addr, 5245 fragS *frag, symbolS *to_symbol) 5246 { 5247 valueT offset; 5248 5249 if (!HAVE_LONG_BRANCH (current_architecture)) 5250 { 5251 if (flag_keep_pcrel) 5252 as_fatal (_("Tried to convert PC relative branch to absolute jump")); 5253 offset = to_addr - S_GET_VALUE (to_symbol); 5254 md_number_to_chars (ptr, (valueT) 0x4EF9, 2); 5255 md_number_to_chars (ptr + 2, (valueT) offset, 4); 5256 fix_new (frag, (ptr + 2) - frag->fr_literal, 4, to_symbol, (offsetT) 0, 5257 0, NO_RELOC); 5258 } 5259 else 5260 { 5261 offset = to_addr - (from_addr + 2); 5262 md_number_to_chars (ptr, (valueT) 0x60ff, 2); 5263 md_number_to_chars (ptr + 2, (valueT) offset, 4); 5264 } 5265 } 5266 5267 #endif 5268 5269 /* Different values of OK tell what its OK to return. Things that 5270 aren't OK are an error (what a shock, no?) 5271 5272 0: Everything is OK 5273 10: Absolute 1:8 only 5274 20: Absolute 0:7 only 5275 30: absolute 0:15 only 5276 40: Absolute 0:31 only 5277 50: absolute 0:127 only 5278 55: absolute -64:63 only 5279 60: absolute -128:127 only 5280 65: absolute 0:511 only 5281 70: absolute 0:4095 only 5282 80: absolute -1, 1:7 only 5283 90: No bignums. */ 5284 5285 static int 5286 get_num (struct m68k_exp *exp, int ok) 5287 { 5288 if (exp->exp.X_op == O_absent) 5289 { 5290 /* Do the same thing the VAX asm does. */ 5291 op (exp) = O_constant; 5292 adds (exp) = 0; 5293 subs (exp) = 0; 5294 offs (exp) = 0; 5295 if (ok == 10) 5296 { 5297 as_warn (_("expression out of range: defaulting to 1")); 5298 offs (exp) = 1; 5299 } 5300 } 5301 else if (exp->exp.X_op == O_constant) 5302 { 5303 switch (ok) 5304 { 5305 case 10: 5306 if ((valueT) TRUNC (offs (exp)) - 1 > 7) 5307 { 5308 as_warn (_("expression out of range: defaulting to 1")); 5309 offs (exp) = 1; 5310 } 5311 break; 5312 case 20: 5313 if ((valueT) TRUNC (offs (exp)) > 7) 5314 goto outrange; 5315 break; 5316 case 30: 5317 if ((valueT) TRUNC (offs (exp)) > 15) 5318 goto outrange; 5319 break; 5320 case 40: 5321 if ((valueT) TRUNC (offs (exp)) > 32) 5322 goto outrange; 5323 break; 5324 case 50: 5325 if ((valueT) TRUNC (offs (exp)) > 127) 5326 goto outrange; 5327 break; 5328 case 55: 5329 if ((valueT) SEXT (offs (exp)) + 64 > 127) 5330 goto outrange; 5331 break; 5332 case 60: 5333 if ((valueT) SEXT (offs (exp)) + 128 > 255) 5334 goto outrange; 5335 break; 5336 case 65: 5337 if ((valueT) TRUNC (offs (exp)) > 511) 5338 goto outrange; 5339 break; 5340 case 70: 5341 if ((valueT) TRUNC (offs (exp)) > 4095) 5342 { 5343 outrange: 5344 as_warn (_("expression out of range: defaulting to 0")); 5345 offs (exp) = 0; 5346 } 5347 break; 5348 case 80: 5349 if ((valueT) TRUNC (offs (exp)) != 0xffffffff 5350 && (valueT) TRUNC (offs (exp)) - 1 > 6) 5351 { 5352 as_warn (_("expression out of range: defaulting to 1")); 5353 offs (exp) = 1; 5354 } 5355 break; 5356 default: 5357 break; 5358 } 5359 } 5360 else if (exp->exp.X_op == O_big) 5361 { 5362 if (offs (exp) <= 0 /* flonum. */ 5363 && (ok == 90 /* no bignums */ 5364 || (ok > 10 /* Small-int ranges including 0 ok. */ 5365 /* If we have a flonum zero, a zero integer should 5366 do as well (e.g., in moveq). */ 5367 && generic_floating_point_number.exponent == 0 5368 && generic_floating_point_number.low[0] == 0))) 5369 { 5370 /* HACK! Turn it into a long. */ 5371 LITTLENUM_TYPE words[6]; 5372 5373 gen_to_words (words, 2, 8L); /* These numbers are magic! */ 5374 op (exp) = O_constant; 5375 adds (exp) = 0; 5376 subs (exp) = 0; 5377 offs (exp) = words[1] | (words[0] << 16); 5378 } 5379 else if (ok != 0) 5380 { 5381 op (exp) = O_constant; 5382 adds (exp) = 0; 5383 subs (exp) = 0; 5384 offs (exp) = (ok == 10) ? 1 : 0; 5385 as_warn (_("Can't deal with expression; defaulting to %ld"), 5386 (long) offs (exp)); 5387 } 5388 } 5389 else 5390 { 5391 if (ok >= 10 && ok <= 80) 5392 { 5393 op (exp) = O_constant; 5394 adds (exp) = 0; 5395 subs (exp) = 0; 5396 offs (exp) = (ok == 10) ? 1 : 0; 5397 as_warn (_("Can't deal with expression; defaulting to %ld"), 5398 (long) offs (exp)); 5399 } 5400 } 5401 5402 if (exp->size != SIZE_UNSPEC) 5403 { 5404 switch (exp->size) 5405 { 5406 case SIZE_UNSPEC: 5407 case SIZE_LONG: 5408 break; 5409 case SIZE_BYTE: 5410 if (!isbyte (offs (exp))) 5411 as_warn (_("expression doesn't fit in BYTE")); 5412 break; 5413 case SIZE_WORD: 5414 if (!isword (offs (exp))) 5415 as_warn (_("expression doesn't fit in WORD")); 5416 break; 5417 } 5418 } 5419 5420 return offs (exp); 5421 } 5422 5423 /* These are the back-ends for the various machine dependent pseudo-ops. */ 5424 5425 static void 5426 s_data1 (int ignore ATTRIBUTE_UNUSED) 5427 { 5428 subseg_set (data_section, 1); 5429 demand_empty_rest_of_line (); 5430 } 5431 5432 static void 5433 s_data2 (int ignore ATTRIBUTE_UNUSED) 5434 { 5435 subseg_set (data_section, 2); 5436 demand_empty_rest_of_line (); 5437 } 5438 5439 static void 5440 s_bss (int ignore ATTRIBUTE_UNUSED) 5441 { 5442 /* We don't support putting frags in the BSS segment, we fake it 5443 by marking in_bss, then looking at s_skip for clues. */ 5444 5445 subseg_set (bss_section, 0); 5446 demand_empty_rest_of_line (); 5447 } 5448 5449 static void 5450 s_even (int ignore ATTRIBUTE_UNUSED) 5451 { 5452 register int temp; 5453 register long temp_fill; 5454 5455 temp = 1; /* JF should be 2? */ 5456 temp_fill = get_absolute_expression (); 5457 if (!need_pass_2) /* Never make frag if expect extra pass. */ 5458 frag_align (temp, (int) temp_fill, 0); 5459 demand_empty_rest_of_line (); 5460 record_alignment (now_seg, temp); 5461 } 5462 5463 static void 5464 s_proc (int ignore ATTRIBUTE_UNUSED) 5465 { 5466 demand_empty_rest_of_line (); 5467 } 5468 5469 /* Pseudo-ops handled for MRI compatibility. */ 5470 5471 /* This function returns non-zero if the argument is a conditional 5472 pseudo-op. This is called when checking whether a pending 5473 alignment is needed. */ 5474 5475 int 5476 m68k_conditional_pseudoop (pseudo_typeS *pop) 5477 { 5478 return (pop->poc_handler == s_mri_if 5479 || pop->poc_handler == s_mri_else); 5480 } 5481 5482 /* Handle an MRI style chip specification. */ 5483 5484 static void 5485 mri_chip (void) 5486 { 5487 char *s; 5488 char c; 5489 int i; 5490 5491 s = input_line_pointer; 5492 /* We can't use get_symbol_end since the processor names are not proper 5493 symbols. */ 5494 while (is_part_of_name (c = *input_line_pointer++)) 5495 ; 5496 *--input_line_pointer = 0; 5497 for (i = 0; m68k_cpus[i].name; i++) 5498 if (strcasecmp (s, m68k_cpus[i].name) == 0) 5499 break; 5500 if (!m68k_cpus[i].name) 5501 { 5502 as_bad (_("%s: unrecognized processor name"), s); 5503 *input_line_pointer = c; 5504 ignore_rest_of_line (); 5505 return; 5506 } 5507 *input_line_pointer = c; 5508 5509 if (*input_line_pointer == '/') 5510 current_architecture = 0; 5511 else 5512 current_architecture &= m68881 | m68851; 5513 current_architecture |= m68k_cpus[i].arch & ~(m68881 | m68851); 5514 control_regs = m68k_cpus[i].control_regs; 5515 5516 while (*input_line_pointer == '/') 5517 { 5518 ++input_line_pointer; 5519 s = input_line_pointer; 5520 /* We can't use get_symbol_end since the processor names are not 5521 proper symbols. */ 5522 while (is_part_of_name (c = *input_line_pointer++)) 5523 ; 5524 *--input_line_pointer = 0; 5525 if (strcmp (s, "68881") == 0) 5526 current_architecture |= m68881; 5527 else if (strcmp (s, "68851") == 0) 5528 current_architecture |= m68851; 5529 *input_line_pointer = c; 5530 } 5531 } 5532 5533 /* The MRI CHIP pseudo-op. */ 5534 5535 static void 5536 s_chip (int ignore ATTRIBUTE_UNUSED) 5537 { 5538 char *stop = NULL; 5539 char stopc; 5540 5541 if (flag_mri) 5542 stop = mri_comment_field (&stopc); 5543 mri_chip (); 5544 if (flag_mri) 5545 mri_comment_end (stop, stopc); 5546 demand_empty_rest_of_line (); 5547 } 5548 5549 /* The MRI FOPT pseudo-op. */ 5550 5551 static void 5552 s_fopt (int ignore ATTRIBUTE_UNUSED) 5553 { 5554 SKIP_WHITESPACE (); 5555 5556 if (strncasecmp (input_line_pointer, "ID=", 3) == 0) 5557 { 5558 int temp; 5559 5560 input_line_pointer += 3; 5561 temp = get_absolute_expression (); 5562 if (temp < 0 || temp > 7) 5563 as_bad (_("bad coprocessor id")); 5564 else 5565 m68k_float_copnum = COP0 + temp; 5566 } 5567 else 5568 { 5569 as_bad (_("unrecognized fopt option")); 5570 ignore_rest_of_line (); 5571 return; 5572 } 5573 5574 demand_empty_rest_of_line (); 5575 } 5576 5577 /* The structure used to handle the MRI OPT pseudo-op. */ 5578 5579 struct opt_action 5580 { 5581 /* The name of the option. */ 5582 const char *name; 5583 5584 /* If this is not NULL, just call this function. The first argument 5585 is the ARG field of this structure, the second argument is 5586 whether the option was negated. */ 5587 void (*pfn) (int arg, int on); 5588 5589 /* If this is not NULL, and the PFN field is NULL, set the variable 5590 this points to. Set it to the ARG field if the option was not 5591 negated, and the NOTARG field otherwise. */ 5592 int *pvar; 5593 5594 /* The value to pass to PFN or to assign to *PVAR. */ 5595 int arg; 5596 5597 /* The value to assign to *PVAR if the option is negated. If PFN is 5598 NULL, and PVAR is not NULL, and ARG and NOTARG are the same, then 5599 the option may not be negated. */ 5600 int notarg; 5601 }; 5602 5603 /* The table used to handle the MRI OPT pseudo-op. */ 5604 5605 static void skip_to_comma (int, int); 5606 static void opt_nest (int, int); 5607 static void opt_chip (int, int); 5608 static void opt_list (int, int); 5609 static void opt_list_symbols (int, int); 5610 5611 static const struct opt_action opt_table[] = 5612 { 5613 { "abspcadd", 0, &m68k_abspcadd, 1, 0 }, 5614 5615 /* We do relaxing, so there is little use for these options. */ 5616 { "b", 0, 0, 0, 0 }, 5617 { "brs", 0, 0, 0, 0 }, 5618 { "brb", 0, 0, 0, 0 }, 5619 { "brl", 0, 0, 0, 0 }, 5620 { "brw", 0, 0, 0, 0 }, 5621 5622 { "c", 0, 0, 0, 0 }, 5623 { "cex", 0, 0, 0, 0 }, 5624 { "case", 0, &symbols_case_sensitive, 1, 0 }, 5625 { "cl", 0, 0, 0, 0 }, 5626 { "cre", 0, 0, 0, 0 }, 5627 { "d", 0, &flag_keep_locals, 1, 0 }, 5628 { "e", 0, 0, 0, 0 }, 5629 { "f", 0, &flag_short_refs, 1, 0 }, 5630 { "frs", 0, &flag_short_refs, 1, 0 }, 5631 { "frl", 0, &flag_short_refs, 0, 1 }, 5632 { "g", 0, 0, 0, 0 }, 5633 { "i", 0, 0, 0, 0 }, 5634 { "m", 0, 0, 0, 0 }, 5635 { "mex", 0, 0, 0, 0 }, 5636 { "mc", 0, 0, 0, 0 }, 5637 { "md", 0, 0, 0, 0 }, 5638 { "nest", opt_nest, 0, 0, 0 }, 5639 { "next", skip_to_comma, 0, 0, 0 }, 5640 { "o", 0, 0, 0, 0 }, 5641 { "old", 0, 0, 0, 0 }, 5642 { "op", skip_to_comma, 0, 0, 0 }, 5643 { "pco", 0, 0, 0, 0 }, 5644 { "p", opt_chip, 0, 0, 0 }, 5645 { "pcr", 0, 0, 0, 0 }, 5646 { "pcs", 0, 0, 0, 0 }, 5647 { "r", 0, 0, 0, 0 }, 5648 { "quick", 0, &m68k_quick, 1, 0 }, 5649 { "rel32", 0, &m68k_rel32, 1, 0 }, 5650 { "s", opt_list, 0, 0, 0 }, 5651 { "t", opt_list_symbols, 0, 0, 0 }, 5652 { "w", 0, &flag_no_warnings, 0, 1 }, 5653 { "x", 0, 0, 0, 0 } 5654 }; 5655 5656 #define OPTCOUNT ((int) (sizeof opt_table / sizeof opt_table[0])) 5657 5658 /* The MRI OPT pseudo-op. */ 5659 5660 static void 5661 s_opt (int ignore ATTRIBUTE_UNUSED) 5662 { 5663 do 5664 { 5665 int t; 5666 char *s; 5667 char c; 5668 int i; 5669 const struct opt_action *o; 5670 5671 SKIP_WHITESPACE (); 5672 5673 t = 1; 5674 if (*input_line_pointer == '-') 5675 { 5676 ++input_line_pointer; 5677 t = 0; 5678 } 5679 else if (strncasecmp (input_line_pointer, "NO", 2) == 0) 5680 { 5681 input_line_pointer += 2; 5682 t = 0; 5683 } 5684 5685 s = input_line_pointer; 5686 c = get_symbol_end (); 5687 5688 for (i = 0, o = opt_table; i < OPTCOUNT; i++, o++) 5689 { 5690 if (strcasecmp (s, o->name) == 0) 5691 { 5692 if (o->pfn) 5693 { 5694 /* Restore input_line_pointer now in case the option 5695 takes arguments. */ 5696 *input_line_pointer = c; 5697 (*o->pfn) (o->arg, t); 5698 } 5699 else if (o->pvar != NULL) 5700 { 5701 if (! t && o->arg == o->notarg) 5702 as_bad (_("option `%s' may not be negated"), s); 5703 *input_line_pointer = c; 5704 *o->pvar = t ? o->arg : o->notarg; 5705 } 5706 else 5707 *input_line_pointer = c; 5708 break; 5709 } 5710 } 5711 if (i >= OPTCOUNT) 5712 { 5713 as_bad (_("option `%s' not recognized"), s); 5714 *input_line_pointer = c; 5715 } 5716 } 5717 while (*input_line_pointer++ == ','); 5718 5719 /* Move back to terminating character. */ 5720 --input_line_pointer; 5721 demand_empty_rest_of_line (); 5722 } 5723 5724 /* Skip ahead to a comma. This is used for OPT options which we do 5725 not support and which take arguments. */ 5726 5727 static void 5728 skip_to_comma (int arg ATTRIBUTE_UNUSED, int on ATTRIBUTE_UNUSED) 5729 { 5730 while (*input_line_pointer != ',' 5731 && ! is_end_of_line[(unsigned char) *input_line_pointer]) 5732 ++input_line_pointer; 5733 } 5734 5735 /* Handle the OPT NEST=depth option. */ 5736 5737 static void 5738 opt_nest (int arg ATTRIBUTE_UNUSED, int on ATTRIBUTE_UNUSED) 5739 { 5740 if (*input_line_pointer != '=') 5741 { 5742 as_bad (_("bad format of OPT NEST=depth")); 5743 return; 5744 } 5745 5746 ++input_line_pointer; 5747 max_macro_nest = get_absolute_expression (); 5748 } 5749 5750 /* Handle the OPT P=chip option. */ 5751 5752 static void 5753 opt_chip (int arg ATTRIBUTE_UNUSED, int on ATTRIBUTE_UNUSED) 5754 { 5755 if (*input_line_pointer != '=') 5756 { 5757 /* This is just OPT P, which we do not support. */ 5758 return; 5759 } 5760 5761 ++input_line_pointer; 5762 mri_chip (); 5763 } 5764 5765 /* Handle the OPT S option. */ 5766 5767 static void 5768 opt_list (int arg ATTRIBUTE_UNUSED, int on) 5769 { 5770 listing_list (on); 5771 } 5772 5773 /* Handle the OPT T option. */ 5774 5775 static void 5776 opt_list_symbols (int arg ATTRIBUTE_UNUSED, int on) 5777 { 5778 if (on) 5779 listing |= LISTING_SYMBOLS; 5780 else 5781 listing &= ~LISTING_SYMBOLS; 5782 } 5783 5784 /* Handle the MRI REG pseudo-op. */ 5785 5786 static void 5787 s_reg (int ignore ATTRIBUTE_UNUSED) 5788 { 5789 char *s; 5790 int c; 5791 struct m68k_op rop; 5792 int mask; 5793 char *stop = NULL; 5794 char stopc; 5795 5796 if (line_label == NULL) 5797 { 5798 as_bad (_("missing label")); 5799 ignore_rest_of_line (); 5800 return; 5801 } 5802 5803 if (flag_mri) 5804 stop = mri_comment_field (&stopc); 5805 5806 SKIP_WHITESPACE (); 5807 5808 s = input_line_pointer; 5809 while (ISALNUM (*input_line_pointer) 5810 #ifdef REGISTER_PREFIX 5811 || *input_line_pointer == REGISTER_PREFIX 5812 #endif 5813 || *input_line_pointer == '/' 5814 || *input_line_pointer == '-') 5815 ++input_line_pointer; 5816 c = *input_line_pointer; 5817 *input_line_pointer = '\0'; 5818 5819 if (m68k_ip_op (s, &rop) != 0) 5820 { 5821 if (rop.error == NULL) 5822 as_bad (_("bad register list")); 5823 else 5824 as_bad (_("bad register list: %s"), rop.error); 5825 *input_line_pointer = c; 5826 ignore_rest_of_line (); 5827 return; 5828 } 5829 5830 *input_line_pointer = c; 5831 5832 if (rop.mode == REGLST) 5833 mask = rop.mask; 5834 else if (rop.mode == DREG) 5835 mask = 1 << (rop.reg - DATA0); 5836 else if (rop.mode == AREG) 5837 mask = 1 << (rop.reg - ADDR0 + 8); 5838 else if (rop.mode == FPREG) 5839 mask = 1 << (rop.reg - FP0 + 16); 5840 else if (rop.mode == CONTROL 5841 && rop.reg == FPI) 5842 mask = 1 << 24; 5843 else if (rop.mode == CONTROL 5844 && rop.reg == FPS) 5845 mask = 1 << 25; 5846 else if (rop.mode == CONTROL 5847 && rop.reg == FPC) 5848 mask = 1 << 26; 5849 else 5850 { 5851 as_bad (_("bad register list")); 5852 ignore_rest_of_line (); 5853 return; 5854 } 5855 5856 S_SET_SEGMENT (line_label, reg_section); 5857 S_SET_VALUE (line_label, ~mask); 5858 symbol_set_frag (line_label, &zero_address_frag); 5859 5860 if (flag_mri) 5861 mri_comment_end (stop, stopc); 5862 5863 demand_empty_rest_of_line (); 5864 } 5865 5866 /* This structure is used for the MRI SAVE and RESTORE pseudo-ops. */ 5867 5868 struct save_opts 5869 { 5870 struct save_opts *next; 5871 int abspcadd; 5872 int symbols_case_sensitive; 5873 int keep_locals; 5874 int short_refs; 5875 int architecture; 5876 const enum m68k_register *control_regs; 5877 int quick; 5878 int rel32; 5879 int listing; 5880 int no_warnings; 5881 /* FIXME: We don't save OPT S. */ 5882 }; 5883 5884 /* This variable holds the stack of saved options. */ 5885 5886 static struct save_opts *save_stack; 5887 5888 /* The MRI SAVE pseudo-op. */ 5889 5890 static void 5891 s_save (int ignore ATTRIBUTE_UNUSED) 5892 { 5893 struct save_opts *s; 5894 5895 s = (struct save_opts *) xmalloc (sizeof (struct save_opts)); 5896 s->abspcadd = m68k_abspcadd; 5897 s->symbols_case_sensitive = symbols_case_sensitive; 5898 s->keep_locals = flag_keep_locals; 5899 s->short_refs = flag_short_refs; 5900 s->architecture = current_architecture; 5901 s->control_regs = control_regs; 5902 s->quick = m68k_quick; 5903 s->rel32 = m68k_rel32; 5904 s->listing = listing; 5905 s->no_warnings = flag_no_warnings; 5906 5907 s->next = save_stack; 5908 save_stack = s; 5909 5910 demand_empty_rest_of_line (); 5911 } 5912 5913 /* The MRI RESTORE pseudo-op. */ 5914 5915 static void 5916 s_restore (int ignore ATTRIBUTE_UNUSED) 5917 { 5918 struct save_opts *s; 5919 5920 if (save_stack == NULL) 5921 { 5922 as_bad (_("restore without save")); 5923 ignore_rest_of_line (); 5924 return; 5925 } 5926 5927 s = save_stack; 5928 save_stack = s->next; 5929 5930 m68k_abspcadd = s->abspcadd; 5931 symbols_case_sensitive = s->symbols_case_sensitive; 5932 flag_keep_locals = s->keep_locals; 5933 flag_short_refs = s->short_refs; 5934 current_architecture = s->architecture; 5935 control_regs = s->control_regs; 5936 m68k_quick = s->quick; 5937 m68k_rel32 = s->rel32; 5938 listing = s->listing; 5939 flag_no_warnings = s->no_warnings; 5940 5941 free (s); 5942 5943 demand_empty_rest_of_line (); 5944 } 5945 5946 /* Types of MRI structured control directives. */ 5947 5948 enum mri_control_type 5949 { 5950 mri_for, 5951 mri_if, 5952 mri_repeat, 5953 mri_while 5954 }; 5955 5956 /* This structure is used to stack the MRI structured control 5957 directives. */ 5958 5959 struct mri_control_info 5960 { 5961 /* The directive within which this one is enclosed. */ 5962 struct mri_control_info *outer; 5963 5964 /* The type of directive. */ 5965 enum mri_control_type type; 5966 5967 /* Whether an ELSE has been in an IF. */ 5968 int else_seen; 5969 5970 /* The add or sub statement at the end of a FOR. */ 5971 char *incr; 5972 5973 /* The label of the top of a FOR or REPEAT loop. */ 5974 char *top; 5975 5976 /* The label to jump to for the next iteration, or the else 5977 expression of a conditional. */ 5978 char *next; 5979 5980 /* The label to jump to to break out of the loop, or the label past 5981 the end of a conditional. */ 5982 char *bottom; 5983 }; 5984 5985 /* The stack of MRI structured control directives. */ 5986 5987 static struct mri_control_info *mri_control_stack; 5988 5989 /* The current MRI structured control directive index number, used to 5990 generate label names. */ 5991 5992 static int mri_control_index; 5993 5994 /* Assemble an instruction for an MRI structured control directive. */ 5995 5996 static void 5997 mri_assemble (char *str) 5998 { 5999 char *s; 6000 6001 /* md_assemble expects the opcode to be in lower case. */ 6002 for (s = str; *s != ' ' && *s != '\0'; s++) 6003 *s = TOLOWER (*s); 6004 6005 md_assemble (str); 6006 } 6007 6008 /* Generate a new MRI label structured control directive label name. */ 6009 6010 static char * 6011 mri_control_label (void) 6012 { 6013 char *n; 6014 6015 n = (char *) xmalloc (20); 6016 sprintf (n, "%smc%d", FAKE_LABEL_NAME, mri_control_index); 6017 ++mri_control_index; 6018 return n; 6019 } 6020 6021 /* Create a new MRI structured control directive. */ 6022 6023 static struct mri_control_info * 6024 push_mri_control (enum mri_control_type type) 6025 { 6026 struct mri_control_info *n; 6027 6028 n = (struct mri_control_info *) xmalloc (sizeof (struct mri_control_info)); 6029 6030 n->type = type; 6031 n->else_seen = 0; 6032 if (type == mri_if || type == mri_while) 6033 n->top = NULL; 6034 else 6035 n->top = mri_control_label (); 6036 n->next = mri_control_label (); 6037 n->bottom = mri_control_label (); 6038 6039 n->outer = mri_control_stack; 6040 mri_control_stack = n; 6041 6042 return n; 6043 } 6044 6045 /* Pop off the stack of MRI structured control directives. */ 6046 6047 static void 6048 pop_mri_control (void) 6049 { 6050 struct mri_control_info *n; 6051 6052 n = mri_control_stack; 6053 mri_control_stack = n->outer; 6054 if (n->top != NULL) 6055 free (n->top); 6056 free (n->next); 6057 free (n->bottom); 6058 free (n); 6059 } 6060 6061 /* Recognize a condition code in an MRI structured control expression. */ 6062 6063 static int 6064 parse_mri_condition (int *pcc) 6065 { 6066 char c1, c2; 6067 6068 know (*input_line_pointer == '<'); 6069 6070 ++input_line_pointer; 6071 c1 = *input_line_pointer++; 6072 c2 = *input_line_pointer++; 6073 6074 if (*input_line_pointer != '>') 6075 { 6076 as_bad (_("syntax error in structured control directive")); 6077 return 0; 6078 } 6079 6080 ++input_line_pointer; 6081 SKIP_WHITESPACE (); 6082 6083 c1 = TOLOWER (c1); 6084 c2 = TOLOWER (c2); 6085 6086 *pcc = (c1 << 8) | c2; 6087 6088 return 1; 6089 } 6090 6091 /* Parse a single operand in an MRI structured control expression. */ 6092 6093 static int 6094 parse_mri_control_operand (int *pcc, char **leftstart, char **leftstop, 6095 char **rightstart, char **rightstop) 6096 { 6097 char *s; 6098 6099 SKIP_WHITESPACE (); 6100 6101 *pcc = -1; 6102 *leftstart = NULL; 6103 *leftstop = NULL; 6104 *rightstart = NULL; 6105 *rightstop = NULL; 6106 6107 if (*input_line_pointer == '<') 6108 { 6109 /* It's just a condition code. */ 6110 return parse_mri_condition (pcc); 6111 } 6112 6113 /* Look ahead for the condition code. */ 6114 for (s = input_line_pointer; *s != '\0'; ++s) 6115 { 6116 if (*s == '<' && s[1] != '\0' && s[2] != '\0' && s[3] == '>') 6117 break; 6118 } 6119 if (*s == '\0') 6120 { 6121 as_bad (_("missing condition code in structured control directive")); 6122 return 0; 6123 } 6124 6125 *leftstart = input_line_pointer; 6126 *leftstop = s; 6127 if (*leftstop > *leftstart 6128 && ((*leftstop)[-1] == ' ' || (*leftstop)[-1] == '\t')) 6129 --*leftstop; 6130 6131 input_line_pointer = s; 6132 if (! parse_mri_condition (pcc)) 6133 return 0; 6134 6135 /* Look ahead for AND or OR or end of line. */ 6136 for (s = input_line_pointer; *s != '\0'; ++s) 6137 { 6138 /* We must make sure we don't misinterpret AND/OR at the end of labels! 6139 if d0 <eq> #FOOAND and d1 <ne> #BAROR then 6140 ^^^ ^^ */ 6141 if ((s == input_line_pointer 6142 || *(s-1) == ' ' 6143 || *(s-1) == '\t') 6144 && ((strncasecmp (s, "AND", 3) == 0 6145 && (s[3] == '.' || ! is_part_of_name (s[3]))) 6146 || (strncasecmp (s, "OR", 2) == 0 6147 && (s[2] == '.' || ! is_part_of_name (s[2]))))) 6148 break; 6149 } 6150 6151 *rightstart = input_line_pointer; 6152 *rightstop = s; 6153 if (*rightstop > *rightstart 6154 && ((*rightstop)[-1] == ' ' || (*rightstop)[-1] == '\t')) 6155 --*rightstop; 6156 6157 input_line_pointer = s; 6158 6159 return 1; 6160 } 6161 6162 #define MCC(b1, b2) (((b1) << 8) | (b2)) 6163 6164 /* Swap the sense of a condition. This changes the condition so that 6165 it generates the same result when the operands are swapped. */ 6166 6167 static int 6168 swap_mri_condition (int cc) 6169 { 6170 switch (cc) 6171 { 6172 case MCC ('h', 'i'): return MCC ('c', 's'); 6173 case MCC ('l', 's'): return MCC ('c', 'c'); 6174 /* <HS> is an alias for <CC>. */ 6175 case MCC ('h', 's'): 6176 case MCC ('c', 'c'): return MCC ('l', 's'); 6177 /* <LO> is an alias for <CS>. */ 6178 case MCC ('l', 'o'): 6179 case MCC ('c', 's'): return MCC ('h', 'i'); 6180 case MCC ('p', 'l'): return MCC ('m', 'i'); 6181 case MCC ('m', 'i'): return MCC ('p', 'l'); 6182 case MCC ('g', 'e'): return MCC ('l', 'e'); 6183 case MCC ('l', 't'): return MCC ('g', 't'); 6184 case MCC ('g', 't'): return MCC ('l', 't'); 6185 case MCC ('l', 'e'): return MCC ('g', 'e'); 6186 /* Issue a warning for conditions we can not swap. */ 6187 case MCC ('n', 'e'): return MCC ('n', 'e'); // no problem here 6188 case MCC ('e', 'q'): return MCC ('e', 'q'); // also no problem 6189 case MCC ('v', 'c'): 6190 case MCC ('v', 's'): 6191 default : 6192 as_warn (_("Condition <%c%c> in structured control directive can not be encoded correctly"), 6193 (char) (cc >> 8), (char) (cc)); 6194 break; 6195 } 6196 return cc; 6197 } 6198 6199 /* Reverse the sense of a condition. */ 6200 6201 static int 6202 reverse_mri_condition (int cc) 6203 { 6204 switch (cc) 6205 { 6206 case MCC ('h', 'i'): return MCC ('l', 's'); 6207 case MCC ('l', 's'): return MCC ('h', 'i'); 6208 /* <HS> is an alias for <CC> */ 6209 case MCC ('h', 's'): return MCC ('l', 'o'); 6210 case MCC ('c', 'c'): return MCC ('c', 's'); 6211 /* <LO> is an alias for <CS> */ 6212 case MCC ('l', 'o'): return MCC ('h', 's'); 6213 case MCC ('c', 's'): return MCC ('c', 'c'); 6214 case MCC ('n', 'e'): return MCC ('e', 'q'); 6215 case MCC ('e', 'q'): return MCC ('n', 'e'); 6216 case MCC ('v', 'c'): return MCC ('v', 's'); 6217 case MCC ('v', 's'): return MCC ('v', 'c'); 6218 case MCC ('p', 'l'): return MCC ('m', 'i'); 6219 case MCC ('m', 'i'): return MCC ('p', 'l'); 6220 case MCC ('g', 'e'): return MCC ('l', 't'); 6221 case MCC ('l', 't'): return MCC ('g', 'e'); 6222 case MCC ('g', 't'): return MCC ('l', 'e'); 6223 case MCC ('l', 'e'): return MCC ('g', 't'); 6224 } 6225 return cc; 6226 } 6227 6228 /* Build an MRI structured control expression. This generates test 6229 and branch instructions. It goes to TRUELAB if the condition is 6230 true, and to FALSELAB if the condition is false. Exactly one of 6231 TRUELAB and FALSELAB will be NULL, meaning to fall through. QUAL 6232 is the size qualifier for the expression. EXTENT is the size to 6233 use for the branch. */ 6234 6235 static void 6236 build_mri_control_operand (int qual, int cc, char *leftstart, char *leftstop, 6237 char *rightstart, char *rightstop, 6238 const char *truelab, const char *falselab, 6239 int extent) 6240 { 6241 char *buf; 6242 char *s; 6243 6244 if (leftstart != NULL) 6245 { 6246 struct m68k_op leftop, rightop; 6247 char c; 6248 6249 /* Swap the compare operands, if necessary, to produce a legal 6250 m68k compare instruction. Comparing a register operand with 6251 a non-register operand requires the register to be on the 6252 right (cmp, cmpa). Comparing an immediate value with 6253 anything requires the immediate value to be on the left 6254 (cmpi). */ 6255 6256 c = *leftstop; 6257 *leftstop = '\0'; 6258 (void) m68k_ip_op (leftstart, &leftop); 6259 *leftstop = c; 6260 6261 c = *rightstop; 6262 *rightstop = '\0'; 6263 (void) m68k_ip_op (rightstart, &rightop); 6264 *rightstop = c; 6265 6266 if (rightop.mode == IMMED 6267 || ((leftop.mode == DREG || leftop.mode == AREG) 6268 && (rightop.mode != DREG && rightop.mode != AREG))) 6269 { 6270 char *temp; 6271 6272 /* Correct conditional handling: 6273 if #1 <lt> d0 then ;means if (1 < d0) 6274 ... 6275 endi 6276 6277 should assemble to: 6278 6279 cmp #1,d0 if we do *not* swap the operands 6280 bgt true we need the swapped condition! 6281 ble false 6282 true: 6283 ... 6284 false: 6285 */ 6286 temp = leftstart; 6287 leftstart = rightstart; 6288 rightstart = temp; 6289 temp = leftstop; 6290 leftstop = rightstop; 6291 rightstop = temp; 6292 } 6293 else 6294 { 6295 cc = swap_mri_condition (cc); 6296 } 6297 } 6298 6299 if (truelab == NULL) 6300 { 6301 cc = reverse_mri_condition (cc); 6302 truelab = falselab; 6303 } 6304 6305 if (leftstart != NULL) 6306 { 6307 buf = (char *) xmalloc (20 6308 + (leftstop - leftstart) 6309 + (rightstop - rightstart)); 6310 s = buf; 6311 *s++ = 'c'; 6312 *s++ = 'm'; 6313 *s++ = 'p'; 6314 if (qual != '\0') 6315 *s++ = TOLOWER (qual); 6316 *s++ = ' '; 6317 memcpy (s, leftstart, leftstop - leftstart); 6318 s += leftstop - leftstart; 6319 *s++ = ','; 6320 memcpy (s, rightstart, rightstop - rightstart); 6321 s += rightstop - rightstart; 6322 *s = '\0'; 6323 mri_assemble (buf); 6324 free (buf); 6325 } 6326 6327 buf = (char *) xmalloc (20 + strlen (truelab)); 6328 s = buf; 6329 *s++ = 'b'; 6330 *s++ = cc >> 8; 6331 *s++ = cc & 0xff; 6332 if (extent != '\0') 6333 *s++ = TOLOWER (extent); 6334 *s++ = ' '; 6335 strcpy (s, truelab); 6336 mri_assemble (buf); 6337 free (buf); 6338 } 6339 6340 /* Parse an MRI structured control expression. This generates test 6341 and branch instructions. STOP is where the expression ends. It 6342 goes to TRUELAB if the condition is true, and to FALSELAB if the 6343 condition is false. Exactly one of TRUELAB and FALSELAB will be 6344 NULL, meaning to fall through. QUAL is the size qualifier for the 6345 expression. EXTENT is the size to use for the branch. */ 6346 6347 static void 6348 parse_mri_control_expression (char *stop, int qual, const char *truelab, 6349 const char *falselab, int extent) 6350 { 6351 int c; 6352 int cc; 6353 char *leftstart; 6354 char *leftstop; 6355 char *rightstart; 6356 char *rightstop; 6357 6358 c = *stop; 6359 *stop = '\0'; 6360 6361 if (! parse_mri_control_operand (&cc, &leftstart, &leftstop, 6362 &rightstart, &rightstop)) 6363 { 6364 *stop = c; 6365 return; 6366 } 6367 6368 if (strncasecmp (input_line_pointer, "AND", 3) == 0) 6369 { 6370 const char *flab; 6371 6372 if (falselab != NULL) 6373 flab = falselab; 6374 else 6375 flab = mri_control_label (); 6376 6377 build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart, 6378 rightstop, (const char *) NULL, flab, extent); 6379 6380 input_line_pointer += 3; 6381 if (*input_line_pointer != '.' 6382 || input_line_pointer[1] == '\0') 6383 qual = '\0'; 6384 else 6385 { 6386 qual = input_line_pointer[1]; 6387 input_line_pointer += 2; 6388 } 6389 6390 if (! parse_mri_control_operand (&cc, &leftstart, &leftstop, 6391 &rightstart, &rightstop)) 6392 { 6393 *stop = c; 6394 return; 6395 } 6396 6397 build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart, 6398 rightstop, truelab, falselab, extent); 6399 6400 if (falselab == NULL) 6401 colon (flab); 6402 } 6403 else if (strncasecmp (input_line_pointer, "OR", 2) == 0) 6404 { 6405 const char *tlab; 6406 6407 if (truelab != NULL) 6408 tlab = truelab; 6409 else 6410 tlab = mri_control_label (); 6411 6412 build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart, 6413 rightstop, tlab, (const char *) NULL, extent); 6414 6415 input_line_pointer += 2; 6416 if (*input_line_pointer != '.' 6417 || input_line_pointer[1] == '\0') 6418 qual = '\0'; 6419 else 6420 { 6421 qual = input_line_pointer[1]; 6422 input_line_pointer += 2; 6423 } 6424 6425 if (! parse_mri_control_operand (&cc, &leftstart, &leftstop, 6426 &rightstart, &rightstop)) 6427 { 6428 *stop = c; 6429 return; 6430 } 6431 6432 build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart, 6433 rightstop, truelab, falselab, extent); 6434 6435 if (truelab == NULL) 6436 colon (tlab); 6437 } 6438 else 6439 { 6440 build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart, 6441 rightstop, truelab, falselab, extent); 6442 } 6443 6444 *stop = c; 6445 if (input_line_pointer != stop) 6446 as_bad (_("syntax error in structured control directive")); 6447 } 6448 6449 /* Handle the MRI IF pseudo-op. This may be a structured control 6450 directive, or it may be a regular assembler conditional, depending 6451 on its operands. */ 6452 6453 static void 6454 s_mri_if (int qual) 6455 { 6456 char *s; 6457 int c; 6458 struct mri_control_info *n; 6459 6460 /* A structured control directive must end with THEN with an 6461 optional qualifier. */ 6462 s = input_line_pointer; 6463 /* We only accept '*' as introduction of comments if preceded by white space 6464 or at first column of a line (I think this can't actually happen here?) 6465 This is important when assembling: 6466 if d0 <ne> 12(a0,d0*2) then 6467 if d0 <ne> #CONST*20 then. */ 6468 while (! (is_end_of_line[(unsigned char) *s] 6469 || (flag_mri 6470 && *s == '*' 6471 && (s == input_line_pointer 6472 || *(s-1) == ' ' 6473 || *(s-1) == '\t')))) 6474 ++s; 6475 --s; 6476 while (s > input_line_pointer && (*s == ' ' || *s == '\t')) 6477 --s; 6478 6479 if (s - input_line_pointer > 1 6480 && s[-1] == '.') 6481 s -= 2; 6482 6483 if (s - input_line_pointer < 3 6484 || strncasecmp (s - 3, "THEN", 4) != 0) 6485 { 6486 if (qual != '\0') 6487 { 6488 as_bad (_("missing then")); 6489 ignore_rest_of_line (); 6490 return; 6491 } 6492 6493 /* It's a conditional. */ 6494 s_if (O_ne); 6495 return; 6496 } 6497 6498 /* Since this might be a conditional if, this pseudo-op will be 6499 called even if we are supported to be ignoring input. Double 6500 check now. Clobber *input_line_pointer so that ignore_input 6501 thinks that this is not a special pseudo-op. */ 6502 c = *input_line_pointer; 6503 *input_line_pointer = 0; 6504 if (ignore_input ()) 6505 { 6506 *input_line_pointer = c; 6507 while (! is_end_of_line[(unsigned char) *input_line_pointer]) 6508 ++input_line_pointer; 6509 demand_empty_rest_of_line (); 6510 return; 6511 } 6512 *input_line_pointer = c; 6513 6514 n = push_mri_control (mri_if); 6515 6516 parse_mri_control_expression (s - 3, qual, (const char *) NULL, 6517 n->next, s[1] == '.' ? s[2] : '\0'); 6518 6519 if (s[1] == '.') 6520 input_line_pointer = s + 3; 6521 else 6522 input_line_pointer = s + 1; 6523 6524 if (flag_mri) 6525 { 6526 while (! is_end_of_line[(unsigned char) *input_line_pointer]) 6527 ++input_line_pointer; 6528 } 6529 6530 demand_empty_rest_of_line (); 6531 } 6532 6533 /* Handle the MRI else pseudo-op. If we are currently doing an MRI 6534 structured IF, associate the ELSE with the IF. Otherwise, assume 6535 it is a conditional else. */ 6536 6537 static void 6538 s_mri_else (int qual) 6539 { 6540 int c; 6541 char *buf; 6542 char q[2]; 6543 6544 if (qual == '\0' 6545 && (mri_control_stack == NULL 6546 || mri_control_stack->type != mri_if 6547 || mri_control_stack->else_seen)) 6548 { 6549 s_else (0); 6550 return; 6551 } 6552 6553 c = *input_line_pointer; 6554 *input_line_pointer = 0; 6555 if (ignore_input ()) 6556 { 6557 *input_line_pointer = c; 6558 while (! is_end_of_line[(unsigned char) *input_line_pointer]) 6559 ++input_line_pointer; 6560 demand_empty_rest_of_line (); 6561 return; 6562 } 6563 *input_line_pointer = c; 6564 6565 if (mri_control_stack == NULL 6566 || mri_control_stack->type != mri_if 6567 || mri_control_stack->else_seen) 6568 { 6569 as_bad (_("else without matching if")); 6570 ignore_rest_of_line (); 6571 return; 6572 } 6573 6574 mri_control_stack->else_seen = 1; 6575 6576 buf = (char *) xmalloc (20 + strlen (mri_control_stack->bottom)); 6577 q[0] = TOLOWER (qual); 6578 q[1] = '\0'; 6579 sprintf (buf, "bra%s %s", q, mri_control_stack->bottom); 6580 mri_assemble (buf); 6581 free (buf); 6582 6583 colon (mri_control_stack->next); 6584 6585 if (flag_mri) 6586 { 6587 while (! is_end_of_line[(unsigned char) *input_line_pointer]) 6588 ++input_line_pointer; 6589 } 6590 6591 demand_empty_rest_of_line (); 6592 } 6593 6594 /* Handle the MRI ENDI pseudo-op. */ 6595 6596 static void 6597 s_mri_endi (int ignore ATTRIBUTE_UNUSED) 6598 { 6599 if (mri_control_stack == NULL 6600 || mri_control_stack->type != mri_if) 6601 { 6602 as_bad (_("endi without matching if")); 6603 ignore_rest_of_line (); 6604 return; 6605 } 6606 6607 /* ignore_input will not return true for ENDI, so we don't need to 6608 worry about checking it again here. */ 6609 6610 if (! mri_control_stack->else_seen) 6611 colon (mri_control_stack->next); 6612 colon (mri_control_stack->bottom); 6613 6614 pop_mri_control (); 6615 6616 if (flag_mri) 6617 { 6618 while (! is_end_of_line[(unsigned char) *input_line_pointer]) 6619 ++input_line_pointer; 6620 } 6621 6622 demand_empty_rest_of_line (); 6623 } 6624 6625 /* Handle the MRI BREAK pseudo-op. */ 6626 6627 static void 6628 s_mri_break (int extent) 6629 { 6630 struct mri_control_info *n; 6631 char *buf; 6632 char ex[2]; 6633 6634 n = mri_control_stack; 6635 while (n != NULL 6636 && n->type != mri_for 6637 && n->type != mri_repeat 6638 && n->type != mri_while) 6639 n = n->outer; 6640 if (n == NULL) 6641 { 6642 as_bad (_("break outside of structured loop")); 6643 ignore_rest_of_line (); 6644 return; 6645 } 6646 6647 buf = (char *) xmalloc (20 + strlen (n->bottom)); 6648 ex[0] = TOLOWER (extent); 6649 ex[1] = '\0'; 6650 sprintf (buf, "bra%s %s", ex, n->bottom); 6651 mri_assemble (buf); 6652 free (buf); 6653 6654 if (flag_mri) 6655 { 6656 while (! is_end_of_line[(unsigned char) *input_line_pointer]) 6657 ++input_line_pointer; 6658 } 6659 6660 demand_empty_rest_of_line (); 6661 } 6662 6663 /* Handle the MRI NEXT pseudo-op. */ 6664 6665 static void 6666 s_mri_next (int extent) 6667 { 6668 struct mri_control_info *n; 6669 char *buf; 6670 char ex[2]; 6671 6672 n = mri_control_stack; 6673 while (n != NULL 6674 && n->type != mri_for 6675 && n->type != mri_repeat 6676 && n->type != mri_while) 6677 n = n->outer; 6678 if (n == NULL) 6679 { 6680 as_bad (_("next outside of structured loop")); 6681 ignore_rest_of_line (); 6682 return; 6683 } 6684 6685 buf = (char *) xmalloc (20 + strlen (n->next)); 6686 ex[0] = TOLOWER (extent); 6687 ex[1] = '\0'; 6688 sprintf (buf, "bra%s %s", ex, n->next); 6689 mri_assemble (buf); 6690 free (buf); 6691 6692 if (flag_mri) 6693 { 6694 while (! is_end_of_line[(unsigned char) *input_line_pointer]) 6695 ++input_line_pointer; 6696 } 6697 6698 demand_empty_rest_of_line (); 6699 } 6700 6701 /* Handle the MRI FOR pseudo-op. */ 6702 6703 static void 6704 s_mri_for (int qual) 6705 { 6706 const char *varstart, *varstop; 6707 const char *initstart, *initstop; 6708 const char *endstart, *endstop; 6709 const char *bystart, *bystop; 6710 int up; 6711 int by; 6712 int extent; 6713 struct mri_control_info *n; 6714 char *buf; 6715 char *s; 6716 char ex[2]; 6717 6718 /* The syntax is 6719 FOR.q var = init { TO | DOWNTO } end [ BY by ] DO.e 6720 */ 6721 6722 SKIP_WHITESPACE (); 6723 varstart = input_line_pointer; 6724 6725 /* Look for the '='. */ 6726 while (! is_end_of_line[(unsigned char) *input_line_pointer] 6727 && *input_line_pointer != '=') 6728 ++input_line_pointer; 6729 if (*input_line_pointer != '=') 6730 { 6731 as_bad (_("missing =")); 6732 ignore_rest_of_line (); 6733 return; 6734 } 6735 6736 varstop = input_line_pointer; 6737 if (varstop > varstart 6738 && (varstop[-1] == ' ' || varstop[-1] == '\t')) 6739 --varstop; 6740 6741 ++input_line_pointer; 6742 6743 initstart = input_line_pointer; 6744 6745 /* Look for TO or DOWNTO. */ 6746 up = 1; 6747 initstop = NULL; 6748 while (! is_end_of_line[(unsigned char) *input_line_pointer]) 6749 { 6750 if (strncasecmp (input_line_pointer, "TO", 2) == 0 6751 && ! is_part_of_name (input_line_pointer[2])) 6752 { 6753 initstop = input_line_pointer; 6754 input_line_pointer += 2; 6755 break; 6756 } 6757 if (strncasecmp (input_line_pointer, "DOWNTO", 6) == 0 6758 && ! is_part_of_name (input_line_pointer[6])) 6759 { 6760 initstop = input_line_pointer; 6761 up = 0; 6762 input_line_pointer += 6; 6763 break; 6764 } 6765 ++input_line_pointer; 6766 } 6767 if (initstop == NULL) 6768 { 6769 as_bad (_("missing to or downto")); 6770 ignore_rest_of_line (); 6771 return; 6772 } 6773 if (initstop > initstart 6774 && (initstop[-1] == ' ' || initstop[-1] == '\t')) 6775 --initstop; 6776 6777 SKIP_WHITESPACE (); 6778 endstart = input_line_pointer; 6779 6780 /* Look for BY or DO. */ 6781 by = 0; 6782 endstop = NULL; 6783 while (! is_end_of_line[(unsigned char) *input_line_pointer]) 6784 { 6785 if (strncasecmp (input_line_pointer, "BY", 2) == 0 6786 && ! is_part_of_name (input_line_pointer[2])) 6787 { 6788 endstop = input_line_pointer; 6789 by = 1; 6790 input_line_pointer += 2; 6791 break; 6792 } 6793 if (strncasecmp (input_line_pointer, "DO", 2) == 0 6794 && (input_line_pointer[2] == '.' 6795 || ! is_part_of_name (input_line_pointer[2]))) 6796 { 6797 endstop = input_line_pointer; 6798 input_line_pointer += 2; 6799 break; 6800 } 6801 ++input_line_pointer; 6802 } 6803 if (endstop == NULL) 6804 { 6805 as_bad (_("missing do")); 6806 ignore_rest_of_line (); 6807 return; 6808 } 6809 if (endstop > endstart 6810 && (endstop[-1] == ' ' || endstop[-1] == '\t')) 6811 --endstop; 6812 6813 if (! by) 6814 { 6815 bystart = "#1"; 6816 bystop = bystart + 2; 6817 } 6818 else 6819 { 6820 SKIP_WHITESPACE (); 6821 bystart = input_line_pointer; 6822 6823 /* Look for DO. */ 6824 bystop = NULL; 6825 while (! is_end_of_line[(unsigned char) *input_line_pointer]) 6826 { 6827 if (strncasecmp (input_line_pointer, "DO", 2) == 0 6828 && (input_line_pointer[2] == '.' 6829 || ! is_part_of_name (input_line_pointer[2]))) 6830 { 6831 bystop = input_line_pointer; 6832 input_line_pointer += 2; 6833 break; 6834 } 6835 ++input_line_pointer; 6836 } 6837 if (bystop == NULL) 6838 { 6839 as_bad (_("missing do")); 6840 ignore_rest_of_line (); 6841 return; 6842 } 6843 if (bystop > bystart 6844 && (bystop[-1] == ' ' || bystop[-1] == '\t')) 6845 --bystop; 6846 } 6847 6848 if (*input_line_pointer != '.') 6849 extent = '\0'; 6850 else 6851 { 6852 extent = input_line_pointer[1]; 6853 input_line_pointer += 2; 6854 } 6855 6856 /* We have fully parsed the FOR operands. Now build the loop. */ 6857 n = push_mri_control (mri_for); 6858 6859 buf = (char *) xmalloc (50 + (input_line_pointer - varstart)); 6860 6861 /* Move init,var. */ 6862 s = buf; 6863 *s++ = 'm'; 6864 *s++ = 'o'; 6865 *s++ = 'v'; 6866 *s++ = 'e'; 6867 if (qual != '\0') 6868 *s++ = TOLOWER (qual); 6869 *s++ = ' '; 6870 memcpy (s, initstart, initstop - initstart); 6871 s += initstop - initstart; 6872 *s++ = ','; 6873 memcpy (s, varstart, varstop - varstart); 6874 s += varstop - varstart; 6875 *s = '\0'; 6876 mri_assemble (buf); 6877 6878 colon (n->top); 6879 6880 /* cmp end,var. */ 6881 s = buf; 6882 *s++ = 'c'; 6883 *s++ = 'm'; 6884 *s++ = 'p'; 6885 if (qual != '\0') 6886 *s++ = TOLOWER (qual); 6887 *s++ = ' '; 6888 memcpy (s, endstart, endstop - endstart); 6889 s += endstop - endstart; 6890 *s++ = ','; 6891 memcpy (s, varstart, varstop - varstart); 6892 s += varstop - varstart; 6893 *s = '\0'; 6894 mri_assemble (buf); 6895 6896 /* bcc bottom. */ 6897 ex[0] = TOLOWER (extent); 6898 ex[1] = '\0'; 6899 if (up) 6900 sprintf (buf, "blt%s %s", ex, n->bottom); 6901 else 6902 sprintf (buf, "bgt%s %s", ex, n->bottom); 6903 mri_assemble (buf); 6904 6905 /* Put together the add or sub instruction used by ENDF. */ 6906 s = buf; 6907 if (up) 6908 strcpy (s, "add"); 6909 else 6910 strcpy (s, "sub"); 6911 s += 3; 6912 if (qual != '\0') 6913 *s++ = TOLOWER (qual); 6914 *s++ = ' '; 6915 memcpy (s, bystart, bystop - bystart); 6916 s += bystop - bystart; 6917 *s++ = ','; 6918 memcpy (s, varstart, varstop - varstart); 6919 s += varstop - varstart; 6920 *s = '\0'; 6921 n->incr = buf; 6922 6923 if (flag_mri) 6924 { 6925 while (! is_end_of_line[(unsigned char) *input_line_pointer]) 6926 ++input_line_pointer; 6927 } 6928 6929 demand_empty_rest_of_line (); 6930 } 6931 6932 /* Handle the MRI ENDF pseudo-op. */ 6933 6934 static void 6935 s_mri_endf (int ignore ATTRIBUTE_UNUSED) 6936 { 6937 if (mri_control_stack == NULL 6938 || mri_control_stack->type != mri_for) 6939 { 6940 as_bad (_("endf without for")); 6941 ignore_rest_of_line (); 6942 return; 6943 } 6944 6945 colon (mri_control_stack->next); 6946 6947 mri_assemble (mri_control_stack->incr); 6948 6949 sprintf (mri_control_stack->incr, "bra %s", mri_control_stack->top); 6950 mri_assemble (mri_control_stack->incr); 6951 6952 free (mri_control_stack->incr); 6953 6954 colon (mri_control_stack->bottom); 6955 6956 pop_mri_control (); 6957 6958 if (flag_mri) 6959 { 6960 while (! is_end_of_line[(unsigned char) *input_line_pointer]) 6961 ++input_line_pointer; 6962 } 6963 6964 demand_empty_rest_of_line (); 6965 } 6966 6967 /* Handle the MRI REPEAT pseudo-op. */ 6968 6969 static void 6970 s_mri_repeat (int ignore ATTRIBUTE_UNUSED) 6971 { 6972 struct mri_control_info *n; 6973 6974 n = push_mri_control (mri_repeat); 6975 colon (n->top); 6976 if (flag_mri) 6977 { 6978 while (! is_end_of_line[(unsigned char) *input_line_pointer]) 6979 ++input_line_pointer; 6980 } 6981 demand_empty_rest_of_line (); 6982 } 6983 6984 /* Handle the MRI UNTIL pseudo-op. */ 6985 6986 static void 6987 s_mri_until (int qual) 6988 { 6989 char *s; 6990 6991 if (mri_control_stack == NULL 6992 || mri_control_stack->type != mri_repeat) 6993 { 6994 as_bad (_("until without repeat")); 6995 ignore_rest_of_line (); 6996 return; 6997 } 6998 6999 colon (mri_control_stack->next); 7000 7001 for (s = input_line_pointer; ! is_end_of_line[(unsigned char) *s]; s++) 7002 ; 7003 7004 parse_mri_control_expression (s, qual, (const char *) NULL, 7005 mri_control_stack->top, '\0'); 7006 7007 colon (mri_control_stack->bottom); 7008 7009 input_line_pointer = s; 7010 7011 pop_mri_control (); 7012 7013 if (flag_mri) 7014 { 7015 while (! is_end_of_line[(unsigned char) *input_line_pointer]) 7016 ++input_line_pointer; 7017 } 7018 7019 demand_empty_rest_of_line (); 7020 } 7021 7022 /* Handle the MRI WHILE pseudo-op. */ 7023 7024 static void 7025 s_mri_while (int qual) 7026 { 7027 char *s; 7028 7029 struct mri_control_info *n; 7030 7031 s = input_line_pointer; 7032 /* We only accept '*' as introduction of comments if preceded by white space 7033 or at first column of a line (I think this can't actually happen here?) 7034 This is important when assembling: 7035 while d0 <ne> 12(a0,d0*2) do 7036 while d0 <ne> #CONST*20 do. */ 7037 while (! (is_end_of_line[(unsigned char) *s] 7038 || (flag_mri 7039 && *s == '*' 7040 && (s == input_line_pointer 7041 || *(s-1) == ' ' 7042 || *(s-1) == '\t')))) 7043 s++; 7044 --s; 7045 while (*s == ' ' || *s == '\t') 7046 --s; 7047 if (s - input_line_pointer > 1 7048 && s[-1] == '.') 7049 s -= 2; 7050 if (s - input_line_pointer < 2 7051 || strncasecmp (s - 1, "DO", 2) != 0) 7052 { 7053 as_bad (_("missing do")); 7054 ignore_rest_of_line (); 7055 return; 7056 } 7057 7058 n = push_mri_control (mri_while); 7059 7060 colon (n->next); 7061 7062 parse_mri_control_expression (s - 1, qual, (const char *) NULL, n->bottom, 7063 s[1] == '.' ? s[2] : '\0'); 7064 7065 input_line_pointer = s + 1; 7066 if (*input_line_pointer == '.') 7067 input_line_pointer += 2; 7068 7069 if (flag_mri) 7070 { 7071 while (! is_end_of_line[(unsigned char) *input_line_pointer]) 7072 ++input_line_pointer; 7073 } 7074 7075 demand_empty_rest_of_line (); 7076 } 7077 7078 /* Handle the MRI ENDW pseudo-op. */ 7079 7080 static void 7081 s_mri_endw (int ignore ATTRIBUTE_UNUSED) 7082 { 7083 char *buf; 7084 7085 if (mri_control_stack == NULL 7086 || mri_control_stack->type != mri_while) 7087 { 7088 as_bad (_("endw without while")); 7089 ignore_rest_of_line (); 7090 return; 7091 } 7092 7093 buf = (char *) xmalloc (20 + strlen (mri_control_stack->next)); 7094 sprintf (buf, "bra %s", mri_control_stack->next); 7095 mri_assemble (buf); 7096 free (buf); 7097 7098 colon (mri_control_stack->bottom); 7099 7100 pop_mri_control (); 7101 7102 if (flag_mri) 7103 { 7104 while (! is_end_of_line[(unsigned char) *input_line_pointer]) 7105 ++input_line_pointer; 7106 } 7107 7108 demand_empty_rest_of_line (); 7109 } 7110 7111 /* Parse a .cpu directive. */ 7112 7113 static void 7114 s_m68k_cpu (int ignored ATTRIBUTE_UNUSED) 7115 { 7116 char saved_char; 7117 char *name; 7118 7119 if (initialized) 7120 { 7121 as_bad (_("already assembled instructions")); 7122 ignore_rest_of_line (); 7123 return; 7124 } 7125 7126 name = input_line_pointer; 7127 while (*input_line_pointer && !ISSPACE(*input_line_pointer)) 7128 input_line_pointer++; 7129 saved_char = *input_line_pointer; 7130 *input_line_pointer = 0; 7131 7132 m68k_set_cpu (name, 1, 0); 7133 7134 *input_line_pointer = saved_char; 7135 demand_empty_rest_of_line (); 7136 return; 7137 } 7138 7139 /* Parse a .arch directive. */ 7140 7141 static void 7142 s_m68k_arch (int ignored ATTRIBUTE_UNUSED) 7143 { 7144 char saved_char; 7145 char *name; 7146 7147 if (initialized) 7148 { 7149 as_bad (_("already assembled instructions")); 7150 ignore_rest_of_line (); 7151 return; 7152 } 7153 7154 name = input_line_pointer; 7155 while (*input_line_pointer && *input_line_pointer != ',' 7156 && !ISSPACE (*input_line_pointer)) 7157 input_line_pointer++; 7158 saved_char = *input_line_pointer; 7159 *input_line_pointer = 0; 7160 7161 if (m68k_set_arch (name, 1, 0)) 7162 { 7163 /* Scan extensions. */ 7164 do 7165 { 7166 *input_line_pointer++ = saved_char; 7167 if (!*input_line_pointer || ISSPACE (*input_line_pointer)) 7168 break; 7169 name = input_line_pointer; 7170 while (*input_line_pointer && *input_line_pointer != ',' 7171 && !ISSPACE (*input_line_pointer)) 7172 input_line_pointer++; 7173 saved_char = *input_line_pointer; 7174 *input_line_pointer = 0; 7175 } 7176 while (m68k_set_extension (name, 1, 0)); 7177 } 7178 7179 *input_line_pointer = saved_char; 7180 demand_empty_rest_of_line (); 7181 return; 7182 } 7183 7184 /* Lookup a cpu name in TABLE and return the slot found. Return NULL 7185 if none is found, the caller is responsible for emitting an error 7186 message. If ALLOW_M is non-zero, we allow an initial 'm' on the 7187 cpu name, if it begins with a '6' (possibly skipping an intervening 7188 'c'. We also allow a 'c' in the same place. if NEGATED is 7189 non-zero, we accept a leading 'no-' and *NEGATED is set to true, if 7190 the option is indeed negated. */ 7191 7192 static const struct m68k_cpu * 7193 m68k_lookup_cpu (const char *arg, const struct m68k_cpu *table, 7194 int allow_m, int *negated) 7195 { 7196 /* allow negated value? */ 7197 if (negated) 7198 { 7199 *negated = 0; 7200 7201 if (arg[0] == 'n' && arg[1] == 'o' && arg[2] == '-') 7202 { 7203 arg += 3; 7204 *negated = 1; 7205 } 7206 } 7207 7208 /* Remove 'm' or 'mc' prefix from 68k variants. */ 7209 if (allow_m) 7210 { 7211 if (arg[0] == 'm') 7212 { 7213 if (arg[1] == '6') 7214 arg += 1; 7215 else if (arg[1] == 'c' && arg[2] == '6') 7216 arg += 2; 7217 } 7218 } 7219 else if (arg[0] == 'c' && arg[1] == '6') 7220 arg += 1; 7221 7222 for (; table->name; table++) 7223 if (!strcmp (arg, table->name)) 7224 { 7225 if (table->alias < -1 || table->alias > 1) 7226 as_bad (_("`%s' is deprecated, use `%s'"), 7227 table->name, table[table->alias < 0 ? 1 : -1].name); 7228 return table; 7229 } 7230 return 0; 7231 } 7232 7233 /* Set the cpu, issuing errors if it is unrecognized. */ 7234 7235 static int 7236 m68k_set_cpu (char const *name, int allow_m, int silent) 7237 { 7238 const struct m68k_cpu *cpu; 7239 7240 cpu = m68k_lookup_cpu (name, m68k_cpus, allow_m, NULL); 7241 7242 if (!cpu) 7243 { 7244 if (!silent) 7245 as_bad (_("cpu `%s' unrecognized"), name); 7246 return 0; 7247 } 7248 selected_cpu = cpu; 7249 return 1; 7250 } 7251 7252 /* Set the architecture, issuing errors if it is unrecognized. */ 7253 7254 static int 7255 m68k_set_arch (char const *name, int allow_m, int silent) 7256 { 7257 const struct m68k_cpu *arch; 7258 7259 arch = m68k_lookup_cpu (name, m68k_archs, allow_m, NULL); 7260 7261 if (!arch) 7262 { 7263 if (!silent) 7264 as_bad (_("architecture `%s' unrecognized"), name); 7265 return 0; 7266 } 7267 selected_arch = arch; 7268 return 1; 7269 } 7270 7271 /* Set the architecture extension, issuing errors if it is 7272 unrecognized, or invalid */ 7273 7274 static int 7275 m68k_set_extension (char const *name, int allow_m, int silent) 7276 { 7277 int negated; 7278 const struct m68k_cpu *ext; 7279 7280 ext = m68k_lookup_cpu (name, m68k_extensions, allow_m, &negated); 7281 7282 if (!ext) 7283 { 7284 if (!silent) 7285 as_bad (_("extension `%s' unrecognized"), name); 7286 return 0; 7287 } 7288 7289 if (negated) 7290 not_current_architecture |= ext->arch; 7291 else 7292 current_architecture |= ext->arch; 7293 return 1; 7294 } 7295 7296 /* md_parse_option 7297 Invocation line includes a switch not recognized by the base assembler. 7298 */ 7299 7300 #ifdef OBJ_ELF 7301 const char *md_shortopts = "lSA:m:kQ:V"; 7302 #else 7303 const char *md_shortopts = "lSA:m:k"; 7304 #endif 7305 7306 struct option md_longopts[] = { 7307 #define OPTION_PIC (OPTION_MD_BASE) 7308 {"pic", no_argument, NULL, OPTION_PIC}, 7309 #define OPTION_REGISTER_PREFIX_OPTIONAL (OPTION_MD_BASE + 1) 7310 {"register-prefix-optional", no_argument, NULL, 7311 OPTION_REGISTER_PREFIX_OPTIONAL}, 7312 #define OPTION_BITWISE_OR (OPTION_MD_BASE + 2) 7313 {"bitwise-or", no_argument, NULL, OPTION_BITWISE_OR}, 7314 #define OPTION_BASE_SIZE_DEFAULT_16 (OPTION_MD_BASE + 3) 7315 {"base-size-default-16", no_argument, NULL, OPTION_BASE_SIZE_DEFAULT_16}, 7316 #define OPTION_BASE_SIZE_DEFAULT_32 (OPTION_MD_BASE + 4) 7317 {"base-size-default-32", no_argument, NULL, OPTION_BASE_SIZE_DEFAULT_32}, 7318 #define OPTION_DISP_SIZE_DEFAULT_16 (OPTION_MD_BASE + 5) 7319 {"disp-size-default-16", no_argument, NULL, OPTION_DISP_SIZE_DEFAULT_16}, 7320 #define OPTION_DISP_SIZE_DEFAULT_32 (OPTION_MD_BASE + 6) 7321 {"disp-size-default-32", no_argument, NULL, OPTION_DISP_SIZE_DEFAULT_32}, 7322 #define OPTION_PCREL (OPTION_MD_BASE + 7) 7323 {"pcrel", no_argument, NULL, OPTION_PCREL}, 7324 {NULL, no_argument, NULL, 0} 7325 }; 7326 size_t md_longopts_size = sizeof (md_longopts); 7327 7328 int 7329 md_parse_option (int c, char *arg) 7330 { 7331 switch (c) 7332 { 7333 case 'l': /* -l means keep external to 2 bit offset 7334 rather than 16 bit one. */ 7335 flag_short_refs = 1; 7336 break; 7337 7338 case 'S': /* -S means that jbsr's always turn into 7339 jsr's. */ 7340 flag_long_jumps = 1; 7341 break; 7342 7343 case OPTION_PCREL: /* --pcrel means never turn PC-relative 7344 branches into absolute jumps. */ 7345 flag_keep_pcrel = 1; 7346 break; 7347 7348 case OPTION_PIC: 7349 case 'k': 7350 flag_want_pic = 1; 7351 break; /* -pic, Position Independent Code. */ 7352 7353 case OPTION_REGISTER_PREFIX_OPTIONAL: 7354 flag_reg_prefix_optional = 1; 7355 reg_prefix_optional_seen = 1; 7356 break; 7357 7358 /* -V: SVR4 argument to print version ID. */ 7359 case 'V': 7360 print_version_id (); 7361 break; 7362 7363 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section 7364 should be emitted or not. FIXME: Not implemented. */ 7365 case 'Q': 7366 break; 7367 7368 case OPTION_BITWISE_OR: 7369 { 7370 char *n, *t; 7371 const char *s; 7372 7373 n = (char *) xmalloc (strlen (m68k_comment_chars) + 1); 7374 t = n; 7375 for (s = m68k_comment_chars; *s != '\0'; s++) 7376 if (*s != '|') 7377 *t++ = *s; 7378 *t = '\0'; 7379 m68k_comment_chars = n; 7380 } 7381 break; 7382 7383 case OPTION_BASE_SIZE_DEFAULT_16: 7384 m68k_index_width_default = SIZE_WORD; 7385 break; 7386 7387 case OPTION_BASE_SIZE_DEFAULT_32: 7388 m68k_index_width_default = SIZE_LONG; 7389 break; 7390 7391 case OPTION_DISP_SIZE_DEFAULT_16: 7392 m68k_rel32 = 0; 7393 m68k_rel32_from_cmdline = 1; 7394 break; 7395 7396 case OPTION_DISP_SIZE_DEFAULT_32: 7397 m68k_rel32 = 1; 7398 m68k_rel32_from_cmdline = 1; 7399 break; 7400 7401 case 'A': 7402 #if WARN_DEPRECATED 7403 as_tsktsk (_ ("option `-A%s' is deprecated: use `-%s'", 7404 arg, arg)); 7405 #endif 7406 /* Intentional fall-through. */ 7407 case 'm': 7408 if (!strncmp (arg, "arch=", 5)) 7409 m68k_set_arch (arg + 5, 1, 0); 7410 else if (!strncmp (arg, "cpu=", 4)) 7411 m68k_set_cpu (arg + 4, 1, 0); 7412 else if (m68k_set_extension (arg, 0, 1)) 7413 ; 7414 else if (m68k_set_arch (arg, 0, 1)) 7415 ; 7416 else if (m68k_set_cpu (arg, 0, 1)) 7417 ; 7418 else 7419 return 0; 7420 break; 7421 7422 default: 7423 return 0; 7424 } 7425 7426 return 1; 7427 } 7428 7429 /* Setup tables from the selected arch and/or cpu */ 7430 7431 static void 7432 m68k_init_arch (void) 7433 { 7434 if (not_current_architecture & current_architecture) 7435 { 7436 as_bad (_("architecture features both enabled and disabled")); 7437 not_current_architecture &= ~current_architecture; 7438 } 7439 if (selected_arch) 7440 { 7441 current_architecture |= selected_arch->arch; 7442 control_regs = selected_arch->control_regs; 7443 } 7444 else 7445 current_architecture |= selected_cpu->arch; 7446 7447 current_architecture &= ~not_current_architecture; 7448 7449 if ((current_architecture & (cfloat | m68881)) == (cfloat | m68881)) 7450 { 7451 /* Determine which float is really meant. */ 7452 if (current_architecture & (m68k_mask & ~m68881)) 7453 current_architecture ^= cfloat; 7454 else 7455 current_architecture ^= m68881; 7456 } 7457 7458 if (selected_cpu) 7459 { 7460 control_regs = selected_cpu->control_regs; 7461 if (current_architecture & ~selected_cpu->arch) 7462 { 7463 as_bad (_("selected processor does not have all features of selected architecture")); 7464 current_architecture 7465 = selected_cpu->arch & ~not_current_architecture; 7466 } 7467 } 7468 7469 if ((current_architecture & m68k_mask) 7470 && (current_architecture & ~m68k_mask)) 7471 { 7472 as_bad (_ ("m68k and cf features both selected")); 7473 if (current_architecture & m68k_mask) 7474 current_architecture &= m68k_mask; 7475 else 7476 current_architecture &= ~m68k_mask; 7477 } 7478 7479 /* Permit m68881 specification with all cpus; those that can't work 7480 with a coprocessor could be doing emulation. */ 7481 if (current_architecture & m68851) 7482 { 7483 if (current_architecture & m68040) 7484 as_warn (_("68040 and 68851 specified; mmu instructions may assemble incorrectly")); 7485 } 7486 /* What other incompatibilities could we check for? */ 7487 7488 if (cpu_of_arch (current_architecture) < m68020 7489 || arch_coldfire_p (current_architecture)) 7490 md_relax_table[TAB (PCINDEX, BYTE)].rlx_more = 0; 7491 7492 initialized = 1; 7493 } 7494 7495 void 7496 md_show_usage (FILE *stream) 7497 { 7498 const char *default_cpu = TARGET_CPU; 7499 int i; 7500 unsigned int default_arch; 7501 7502 /* Get the canonical name for the default target CPU. */ 7503 if (*default_cpu == 'm') 7504 default_cpu++; 7505 for (i = 0; m68k_cpus[i].name; i++) 7506 { 7507 if (strcasecmp (default_cpu, m68k_cpus[i].name) == 0) 7508 { 7509 default_arch = m68k_cpus[i].arch; 7510 while (m68k_cpus[i].alias > 0) 7511 i--; 7512 while (m68k_cpus[i].alias < 0) 7513 i++; 7514 default_cpu = m68k_cpus[i].name; 7515 } 7516 } 7517 7518 fprintf (stream, _("\ 7519 -march=<arch> set architecture\n\ 7520 -mcpu=<cpu> set cpu [default %s]\n\ 7521 "), default_cpu); 7522 for (i = 0; m68k_extensions[i].name; i++) 7523 fprintf (stream, _("\ 7524 -m[no-]%-16s enable/disable%s architecture extension\n\ 7525 "), m68k_extensions[i].name, 7526 m68k_extensions[i].alias > 0 ? " ColdFire" 7527 : m68k_extensions[i].alias < 0 ? " m68k" : ""); 7528 7529 fprintf (stream, _("\ 7530 -l use 1 word for refs to undefined symbols [default 2]\n\ 7531 -pic, -k generate position independent code\n\ 7532 -S turn jbsr into jsr\n\ 7533 --pcrel never turn PC-relative branches into absolute jumps\n\ 7534 --register-prefix-optional\n\ 7535 recognize register names without prefix character\n\ 7536 --bitwise-or do not treat `|' as a comment character\n\ 7537 --base-size-default-16 base reg without size is 16 bits\n\ 7538 --base-size-default-32 base reg without size is 32 bits (default)\n\ 7539 --disp-size-default-16 displacement with unknown size is 16 bits\n\ 7540 --disp-size-default-32 displacement with unknown size is 32 bits (default)\n\ 7541 ")); 7542 7543 fprintf (stream, _("Architecture variants are: ")); 7544 for (i = 0; m68k_archs[i].name; i++) 7545 { 7546 if (i) 7547 fprintf (stream, " | "); 7548 fprintf (stream, "%s", m68k_archs[i].name); 7549 } 7550 fprintf (stream, "\n"); 7551 7552 fprintf (stream, _("Processor variants are: ")); 7553 for (i = 0; m68k_cpus[i].name; i++) 7554 { 7555 if (i) 7556 fprintf (stream, " | "); 7557 fprintf (stream, "%s", m68k_cpus[i].name); 7558 } 7559 fprintf (stream, _("\n")); 7560 } 7561 7562 #ifdef TEST2 7563 7564 /* TEST2: Test md_assemble() */ 7565 /* Warning, this routine probably doesn't work anymore. */ 7566 int 7567 main (void) 7568 { 7569 struct m68k_it the_ins; 7570 char buf[120]; 7571 char *cp; 7572 int n; 7573 7574 m68k_ip_begin (); 7575 for (;;) 7576 { 7577 if (!gets (buf) || !*buf) 7578 break; 7579 if (buf[0] == '|' || buf[1] == '.') 7580 continue; 7581 for (cp = buf; *cp; cp++) 7582 if (*cp == '\t') 7583 *cp = ' '; 7584 if (is_label (buf)) 7585 continue; 7586 memset (&the_ins, '\0', sizeof (the_ins)); 7587 m68k_ip (&the_ins, buf); 7588 if (the_ins.error) 7589 { 7590 printf (_("Error %s in %s\n"), the_ins.error, buf); 7591 } 7592 else 7593 { 7594 printf (_("Opcode(%d.%s): "), the_ins.numo, the_ins.args); 7595 for (n = 0; n < the_ins.numo; n++) 7596 printf (" 0x%x", the_ins.opcode[n] & 0xffff); 7597 printf (" "); 7598 print_the_insn (&the_ins.opcode[0], stdout); 7599 (void) putchar ('\n'); 7600 } 7601 for (n = 0; n < strlen (the_ins.args) / 2; n++) 7602 { 7603 if (the_ins.operands[n].error) 7604 { 7605 printf ("op%d Error %s in %s\n", n, the_ins.operands[n].error, buf); 7606 continue; 7607 } 7608 printf ("mode %d, reg %d, ", the_ins.operands[n].mode, 7609 the_ins.operands[n].reg); 7610 if (the_ins.operands[n].b_const) 7611 printf ("Constant: '%.*s', ", 7612 1 + the_ins.operands[n].e_const - the_ins.operands[n].b_const, 7613 the_ins.operands[n].b_const); 7614 printf ("ireg %d, isiz %d, imul %d, ", the_ins.operands[n].ireg, 7615 the_ins.operands[n].isiz, the_ins.operands[n].imul); 7616 if (the_ins.operands[n].b_iadd) 7617 printf ("Iadd: '%.*s',", 7618 1 + the_ins.operands[n].e_iadd - the_ins.operands[n].b_iadd, 7619 the_ins.operands[n].b_iadd); 7620 putchar ('\n'); 7621 } 7622 } 7623 m68k_ip_end (); 7624 return 0; 7625 } 7626 7627 int 7628 is_label (char *str) 7629 { 7630 while (*str == ' ') 7631 str++; 7632 while (*str && *str != ' ') 7633 str++; 7634 if (str[-1] == ':' || str[1] == '=') 7635 return 1; 7636 return 0; 7637 } 7638 7639 #endif 7640 7641 /* Possible states for relaxation: 7642 7643 0 0 branch offset byte (bra, etc) 7644 0 1 word 7645 0 2 long 7646 7647 1 0 indexed offsets byte a0@(32,d4:w:1) etc 7648 1 1 word 7649 1 2 long 7650 7651 2 0 two-offset index word-word a0@(32,d4)@(45) etc 7652 2 1 word-long 7653 2 2 long-word 7654 2 3 long-long 7655 7656 */ 7657 7658 /* We have no need to default values of symbols. */ 7659 7660 symbolS * 7661 md_undefined_symbol (char *name ATTRIBUTE_UNUSED) 7662 { 7663 return 0; 7664 } 7665 7666 /* Round up a section size to the appropriate boundary. */ 7667 valueT 7668 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size) 7669 { 7670 #ifdef OBJ_AOUT 7671 /* For a.out, force the section size to be aligned. If we don't do 7672 this, BFD will align it for us, but it will not write out the 7673 final bytes of the section. This may be a bug in BFD, but it is 7674 easier to fix it here since that is how the other a.out targets 7675 work. */ 7676 int align; 7677 7678 align = bfd_get_section_alignment (stdoutput, segment); 7679 size = ((size + (1 << align) - 1) & ((valueT) -1 << align)); 7680 #endif 7681 7682 return size; 7683 } 7684 7685 /* Exactly what point is a PC-relative offset relative TO? 7686 On the 68k, it is relative to the address of the first extension 7687 word. The difference between the addresses of the offset and the 7688 first extension word is stored in fx_pcrel_adjust. */ 7689 long 7690 md_pcrel_from (fixS *fixP) 7691 { 7692 int adjust; 7693 7694 /* Because fx_pcrel_adjust is a char, and may be unsigned, we explicitly 7695 sign extend the value here. */ 7696 adjust = ((fixP->fx_pcrel_adjust & 0xff) ^ 0x80) - 0x80; 7697 if (adjust == 64) 7698 adjust = -1; 7699 return fixP->fx_where + fixP->fx_frag->fr_address - adjust; 7700 } 7701 7702 #ifdef OBJ_ELF 7703 void 7704 m68k_elf_final_processing (void) 7705 { 7706 unsigned flags = 0; 7707 7708 if (arch_coldfire_fpu (current_architecture)) 7709 flags |= EF_M68K_CFV4E; 7710 /* Set file-specific flags if this is a cpu32 processor. */ 7711 if (cpu_of_arch (current_architecture) & cpu32) 7712 flags |= EF_M68K_CPU32; 7713 else if (cpu_of_arch (current_architecture) & fido_a) 7714 flags |= EF_M68K_FIDO; 7715 else if ((cpu_of_arch (current_architecture) & m68000up) 7716 && !(cpu_of_arch (current_architecture) & m68020up)) 7717 flags |= EF_M68K_M68000; 7718 7719 if (current_architecture & mcfisa_a) 7720 { 7721 static const unsigned isa_features[][2] = 7722 { 7723 {EF_M68K_CF_ISA_A_NODIV,mcfisa_a}, 7724 {EF_M68K_CF_ISA_A, mcfisa_a|mcfhwdiv}, 7725 {EF_M68K_CF_ISA_A_PLUS, mcfisa_a|mcfisa_aa|mcfhwdiv|mcfusp}, 7726 {EF_M68K_CF_ISA_B_NOUSP,mcfisa_a|mcfisa_b|mcfhwdiv}, 7727 {EF_M68K_CF_ISA_B, mcfisa_a|mcfisa_b|mcfhwdiv|mcfusp}, 7728 {EF_M68K_CF_ISA_C, mcfisa_a|mcfisa_c|mcfhwdiv|mcfusp}, 7729 {EF_M68K_CF_ISA_C_NODIV,mcfisa_a|mcfisa_c|mcfusp}, 7730 {0,0}, 7731 }; 7732 static const unsigned mac_features[][2] = 7733 { 7734 {EF_M68K_CF_MAC, mcfmac}, 7735 {EF_M68K_CF_EMAC, mcfemac}, 7736 {0,0}, 7737 }; 7738 unsigned ix; 7739 unsigned pattern; 7740 7741 pattern = (current_architecture 7742 & (mcfisa_a|mcfisa_aa|mcfisa_b|mcfisa_c|mcfhwdiv|mcfusp)); 7743 for (ix = 0; isa_features[ix][1]; ix++) 7744 { 7745 if (pattern == isa_features[ix][1]) 7746 { 7747 flags |= isa_features[ix][0]; 7748 break; 7749 } 7750 } 7751 if (!isa_features[ix][1]) 7752 { 7753 cf_bad: 7754 as_warn (_("Not a defined coldfire architecture")); 7755 } 7756 else 7757 { 7758 if (current_architecture & cfloat) 7759 flags |= EF_M68K_CF_FLOAT | EF_M68K_CFV4E; 7760 7761 pattern = current_architecture & (mcfmac|mcfemac); 7762 if (pattern) 7763 { 7764 for (ix = 0; mac_features[ix][1]; ix++) 7765 { 7766 if (pattern == mac_features[ix][1]) 7767 { 7768 flags |= mac_features[ix][0]; 7769 break; 7770 } 7771 } 7772 if (!mac_features[ix][1]) 7773 goto cf_bad; 7774 } 7775 } 7776 } 7777 elf_elfheader (stdoutput)->e_flags |= flags; 7778 } 7779 #endif 7780 7781 int 7782 tc_m68k_regname_to_dw2regnum (char *regname) 7783 { 7784 unsigned int regnum; 7785 static const char *const regnames[] = 7786 { 7787 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", 7788 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "sp", 7789 "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7", 7790 "pc" 7791 }; 7792 7793 for (regnum = 0; regnum < ARRAY_SIZE (regnames); regnum++) 7794 if (strcmp (regname, regnames[regnum]) == 0) 7795 return regnum; 7796 7797 return -1; 7798 } 7799 7800 void 7801 tc_m68k_frame_initial_instructions (void) 7802 { 7803 static int sp_regno = -1; 7804 7805 if (sp_regno < 0) 7806 sp_regno = tc_m68k_regname_to_dw2regnum ("sp"); 7807 7808 cfi_add_CFA_def_cfa (sp_regno, -DWARF2_CIE_DATA_ALIGNMENT); 7809 cfi_add_CFA_offset (DWARF2_DEFAULT_RETURN_COLUMN, DWARF2_CIE_DATA_ALIGNMENT); 7810 } 7811