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