1 /* tc-mips.c -- assemble code for a MIPS chip.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
4 Free Software Foundation, Inc.
5 Contributed by the OSF and Ralph Campbell.
6 Written by Keith Knowles and Ralph Campbell, working independently.
7 Modified for ECOFF and R4000 support by Ian Lance Taylor of Cygnus
10 This file is part of GAS.
12 GAS is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3, or (at your option)
17 GAS is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with GAS; see the file COPYING. If not, write to the Free
24 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
30 #include "safe-ctype.h"
32 #include "opcode/mips.h"
34 #include "dwarf2dbg.h"
35 #include "dw2gencfi.h"
37 /* Check assumptions made in this file. */
38 typedef char static_assert1
[sizeof (offsetT
) < 8 ? -1 : 1];
39 typedef char static_assert2
[sizeof (valueT
) < 8 ? -1 : 1];
42 #define DBG(x) printf x
47 /* Clean up namespace so we can include obj-elf.h too. */
48 static int mips_output_flavor (void);
49 static int mips_output_flavor (void) { return OUTPUT_FLAVOR
; }
50 #undef OBJ_PROCESS_STAB
57 #undef obj_frob_file_after_relocs
58 #undef obj_frob_symbol
60 #undef obj_sec_sym_ok_for_reloc
61 #undef OBJ_COPY_SYMBOL_ATTRIBUTES
64 /* Fix any of them that we actually care about. */
66 #define OUTPUT_FLAVOR mips_output_flavor()
70 #ifndef ECOFF_DEBUGGING
71 #define NO_ECOFF_DEBUGGING
72 #define ECOFF_DEBUGGING 0
75 int mips_flag_mdebug
= -1;
77 /* Control generation of .pdr sections. Off by default on IRIX: the native
78 linker doesn't know about and discards them, but relocations against them
79 remain, leading to rld crashes. */
81 int mips_flag_pdr
= FALSE
;
83 int mips_flag_pdr
= TRUE
;
88 static char *mips_regmask_frag
;
95 #define PIC_CALL_REG 25
103 #define ILLEGAL_REG (32)
105 #define AT mips_opts.at
107 extern int target_big_endian
;
109 /* The name of the readonly data section. */
110 #define RDATA_SECTION_NAME ".rodata"
112 /* Ways in which an instruction can be "appended" to the output. */
114 /* Just add it normally. */
117 /* Add it normally and then add a nop. */
120 /* Turn an instruction with a delay slot into a "compact" version. */
123 /* Insert the instruction before the last one. */
127 /* Information about an instruction, including its format, operands
131 /* The opcode's entry in mips_opcodes or mips16_opcodes. */
132 const struct mips_opcode
*insn_mo
;
134 /* The 16-bit or 32-bit bitstring of the instruction itself. This is
135 a copy of INSN_MO->match with the operands filled in. If we have
136 decided to use an extended MIPS16 instruction, this includes the
138 unsigned long insn_opcode
;
140 /* The frag that contains the instruction. */
143 /* The offset into FRAG of the first instruction byte. */
146 /* The relocs associated with the instruction, if any. */
149 /* True if this entry cannot be moved from its current position. */
150 unsigned int fixed_p
: 1;
152 /* True if this instruction occurred in a .set noreorder block. */
153 unsigned int noreorder_p
: 1;
155 /* True for mips16 instructions that jump to an absolute address. */
156 unsigned int mips16_absolute_jump_p
: 1;
158 /* True if this instruction is complete. */
159 unsigned int complete_p
: 1;
161 /* True if this instruction is cleared from history by unconditional
163 unsigned int cleared_p
: 1;
166 /* The ABI to use. */
177 /* MIPS ABI we are using for this output file. */
178 static enum mips_abi_level mips_abi
= NO_ABI
;
180 /* Whether or not we have code that can call pic code. */
181 int mips_abicalls
= FALSE
;
183 /* Whether or not we have code which can be put into a shared
185 static bfd_boolean mips_in_shared
= TRUE
;
187 /* This is the set of options which may be modified by the .set
188 pseudo-op. We use a struct so that .set push and .set pop are more
191 struct mips_set_options
193 /* MIPS ISA (Instruction Set Architecture) level. This is set to -1
194 if it has not been initialized. Changed by `.set mipsN', and the
195 -mipsN command line option, and the default CPU. */
197 /* Enabled Application Specific Extensions (ASEs). Changed by `.set
198 <asename>', by command line options, and based on the default
201 /* Whether we are assembling for the mips16 processor. 0 if we are
202 not, 1 if we are, and -1 if the value has not been initialized.
203 Changed by `.set mips16' and `.set nomips16', and the -mips16 and
204 -nomips16 command line options, and the default CPU. */
206 /* Whether we are assembling for the mipsMIPS ASE. 0 if we are not,
207 1 if we are, and -1 if the value has not been initialized. Changed
208 by `.set micromips' and `.set nomicromips', and the -mmicromips
209 and -mno-micromips command line options, and the default CPU. */
211 /* Non-zero if we should not reorder instructions. Changed by `.set
212 reorder' and `.set noreorder'. */
214 /* Non-zero if we should not permit the register designated "assembler
215 temporary" to be used in instructions. The value is the register
216 number, normally $at ($1). Changed by `.set at=REG', `.set noat'
217 (same as `.set at=$0') and `.set at' (same as `.set at=$1'). */
219 /* Non-zero if we should warn when a macro instruction expands into
220 more than one machine instruction. Changed by `.set nomacro' and
222 int warn_about_macros
;
223 /* Non-zero if we should not move instructions. Changed by `.set
224 move', `.set volatile', `.set nomove', and `.set novolatile'. */
226 /* Non-zero if we should not optimize branches by moving the target
227 of the branch into the delay slot. Actually, we don't perform
228 this optimization anyhow. Changed by `.set bopt' and `.set
231 /* Non-zero if we should not autoextend mips16 instructions.
232 Changed by `.set autoextend' and `.set noautoextend'. */
234 /* True if we should only emit 32-bit microMIPS instructions.
235 Changed by `.set insn32' and `.set noinsn32', and the -minsn32
236 and -mno-insn32 command line options. */
238 /* Restrict general purpose registers and floating point registers
239 to 32 bit. This is initially determined when -mgp32 or -mfp32
240 is passed but can changed if the assembler code uses .set mipsN. */
243 /* MIPS architecture (CPU) type. Changed by .set arch=FOO, the -march
244 command line option, and the default CPU. */
246 /* True if ".set sym32" is in effect. */
248 /* True if floating-point operations are not allowed. Changed by .set
249 softfloat or .set hardfloat, by command line options -msoft-float or
250 -mhard-float. The default is false. */
251 bfd_boolean soft_float
;
253 /* True if only single-precision floating-point operations are allowed.
254 Changed by .set singlefloat or .set doublefloat, command-line options
255 -msingle-float or -mdouble-float. The default is false. */
256 bfd_boolean single_float
;
259 /* This is the struct we use to hold the current set of options. Note
260 that we must set the isa field to ISA_UNKNOWN and the ASE fields to
261 -1 to indicate that they have not been initialized. */
263 /* True if -mgp32 was passed. */
264 static int file_mips_gp32
= -1;
266 /* True if -mfp32 was passed. */
267 static int file_mips_fp32
= -1;
269 /* 1 if -msoft-float, 0 if -mhard-float. The default is 0. */
270 static int file_mips_soft_float
= 0;
272 /* 1 if -msingle-float, 0 if -mdouble-float. The default is 0. */
273 static int file_mips_single_float
= 0;
275 static struct mips_set_options mips_opts
=
277 /* isa */ ISA_UNKNOWN
, /* ase */ 0, /* mips16 */ -1, /* micromips */ -1,
278 /* noreorder */ 0, /* at */ ATREG
, /* warn_about_macros */ 0,
279 /* nomove */ 0, /* nobopt */ 0, /* noautoextend */ 0, /* insn32 */ FALSE
,
280 /* gp32 */ 0, /* fp32 */ 0, /* arch */ CPU_UNKNOWN
, /* sym32 */ FALSE
,
281 /* soft_float */ FALSE
, /* single_float */ FALSE
284 /* The set of ASEs that were selected on the command line, either
285 explicitly via ASE options or implicitly through things like -march. */
286 static unsigned int file_ase
;
288 /* Which bits of file_ase were explicitly set or cleared by ASE options. */
289 static unsigned int file_ase_explicit
;
291 /* These variables are filled in with the masks of registers used.
292 The object format code reads them and puts them in the appropriate
294 unsigned long mips_gprmask
;
295 unsigned long mips_cprmask
[4];
297 /* MIPS ISA we are using for this output file. */
298 static int file_mips_isa
= ISA_UNKNOWN
;
300 /* True if any MIPS16 code was produced. */
301 static int file_ase_mips16
;
303 #define ISA_SUPPORTS_MIPS16E (mips_opts.isa == ISA_MIPS32 \
304 || mips_opts.isa == ISA_MIPS32R2 \
305 || mips_opts.isa == ISA_MIPS64 \
306 || mips_opts.isa == ISA_MIPS64R2)
308 /* True if any microMIPS code was produced. */
309 static int file_ase_micromips
;
311 /* True if we want to create R_MIPS_JALR for jalr $25. */
313 #define MIPS_JALR_HINT_P(EXPR) HAVE_NEWABI
315 /* As a GNU extension, we use R_MIPS_JALR for o32 too. However,
316 because there's no place for any addend, the only acceptable
317 expression is a bare symbol. */
318 #define MIPS_JALR_HINT_P(EXPR) \
319 (!HAVE_IN_PLACE_ADDENDS \
320 || ((EXPR)->X_op == O_symbol && (EXPR)->X_add_number == 0))
323 /* The argument of the -march= flag. The architecture we are assembling. */
324 static int file_mips_arch
= CPU_UNKNOWN
;
325 static const char *mips_arch_string
;
327 /* The argument of the -mtune= flag. The architecture for which we
329 static int mips_tune
= CPU_UNKNOWN
;
330 static const char *mips_tune_string
;
332 /* True when generating 32-bit code for a 64-bit processor. */
333 static int mips_32bitmode
= 0;
335 /* True if the given ABI requires 32-bit registers. */
336 #define ABI_NEEDS_32BIT_REGS(ABI) ((ABI) == O32_ABI)
338 /* Likewise 64-bit registers. */
339 #define ABI_NEEDS_64BIT_REGS(ABI) \
341 || (ABI) == N64_ABI \
344 /* Return true if ISA supports 64 bit wide gp registers. */
345 #define ISA_HAS_64BIT_REGS(ISA) \
346 ((ISA) == ISA_MIPS3 \
347 || (ISA) == ISA_MIPS4 \
348 || (ISA) == ISA_MIPS5 \
349 || (ISA) == ISA_MIPS64 \
350 || (ISA) == ISA_MIPS64R2)
352 /* Return true if ISA supports 64 bit wide float registers. */
353 #define ISA_HAS_64BIT_FPRS(ISA) \
354 ((ISA) == ISA_MIPS3 \
355 || (ISA) == ISA_MIPS4 \
356 || (ISA) == ISA_MIPS5 \
357 || (ISA) == ISA_MIPS32R2 \
358 || (ISA) == ISA_MIPS64 \
359 || (ISA) == ISA_MIPS64R2)
361 /* Return true if ISA supports 64-bit right rotate (dror et al.)
363 #define ISA_HAS_DROR(ISA) \
364 ((ISA) == ISA_MIPS64R2 \
365 || (mips_opts.micromips \
366 && ISA_HAS_64BIT_REGS (ISA)) \
369 /* Return true if ISA supports 32-bit right rotate (ror et al.)
371 #define ISA_HAS_ROR(ISA) \
372 ((ISA) == ISA_MIPS32R2 \
373 || (ISA) == ISA_MIPS64R2 \
374 || (mips_opts.ase & ASE_SMARTMIPS) \
375 || mips_opts.micromips \
378 /* Return true if ISA supports single-precision floats in odd registers. */
379 #define ISA_HAS_ODD_SINGLE_FPR(ISA) \
380 ((ISA) == ISA_MIPS32 \
381 || (ISA) == ISA_MIPS32R2 \
382 || (ISA) == ISA_MIPS64 \
383 || (ISA) == ISA_MIPS64R2)
385 /* Return true if ISA supports move to/from high part of a 64-bit
386 floating-point register. */
387 #define ISA_HAS_MXHC1(ISA) \
388 ((ISA) == ISA_MIPS32R2 \
389 || (ISA) == ISA_MIPS64R2)
391 #define HAVE_32BIT_GPRS \
392 (mips_opts.gp32 || !ISA_HAS_64BIT_REGS (mips_opts.isa))
394 #define HAVE_32BIT_FPRS \
395 (mips_opts.fp32 || !ISA_HAS_64BIT_FPRS (mips_opts.isa))
397 #define HAVE_64BIT_GPRS (!HAVE_32BIT_GPRS)
398 #define HAVE_64BIT_FPRS (!HAVE_32BIT_FPRS)
400 #define HAVE_NEWABI (mips_abi == N32_ABI || mips_abi == N64_ABI)
402 #define HAVE_64BIT_OBJECTS (mips_abi == N64_ABI)
404 /* True if relocations are stored in-place. */
405 #define HAVE_IN_PLACE_ADDENDS (!HAVE_NEWABI)
407 /* The ABI-derived address size. */
408 #define HAVE_64BIT_ADDRESSES \
409 (HAVE_64BIT_GPRS && (mips_abi == EABI_ABI || mips_abi == N64_ABI))
410 #define HAVE_32BIT_ADDRESSES (!HAVE_64BIT_ADDRESSES)
412 /* The size of symbolic constants (i.e., expressions of the form
413 "SYMBOL" or "SYMBOL + OFFSET"). */
414 #define HAVE_32BIT_SYMBOLS \
415 (HAVE_32BIT_ADDRESSES || !HAVE_64BIT_OBJECTS || mips_opts.sym32)
416 #define HAVE_64BIT_SYMBOLS (!HAVE_32BIT_SYMBOLS)
418 /* Addresses are loaded in different ways, depending on the address size
419 in use. The n32 ABI Documentation also mandates the use of additions
420 with overflow checking, but existing implementations don't follow it. */
421 #define ADDRESS_ADD_INSN \
422 (HAVE_32BIT_ADDRESSES ? "addu" : "daddu")
424 #define ADDRESS_ADDI_INSN \
425 (HAVE_32BIT_ADDRESSES ? "addiu" : "daddiu")
427 #define ADDRESS_LOAD_INSN \
428 (HAVE_32BIT_ADDRESSES ? "lw" : "ld")
430 #define ADDRESS_STORE_INSN \
431 (HAVE_32BIT_ADDRESSES ? "sw" : "sd")
433 /* Return true if the given CPU supports the MIPS16 ASE. */
434 #define CPU_HAS_MIPS16(cpu) \
435 (strncmp (TARGET_CPU, "mips16", sizeof ("mips16") - 1) == 0 \
436 || strncmp (TARGET_CANONICAL, "mips-lsi-elf", sizeof ("mips-lsi-elf") - 1) == 0)
438 /* Return true if the given CPU supports the microMIPS ASE. */
439 #define CPU_HAS_MICROMIPS(cpu) 0
441 /* True if CPU has a dror instruction. */
442 #define CPU_HAS_DROR(CPU) ((CPU) == CPU_VR5400 || (CPU) == CPU_VR5500)
444 /* True if CPU has a ror instruction. */
445 #define CPU_HAS_ROR(CPU) CPU_HAS_DROR (CPU)
447 /* True if CPU is in the Octeon family */
448 #define CPU_IS_OCTEON(CPU) ((CPU) == CPU_OCTEON || (CPU) == CPU_OCTEONP || (CPU) == CPU_OCTEON2)
450 /* True if CPU has seq/sne and seqi/snei instructions. */
451 #define CPU_HAS_SEQ(CPU) (CPU_IS_OCTEON (CPU))
453 /* True, if CPU has support for ldc1 and sdc1. */
454 #define CPU_HAS_LDC1_SDC1(CPU) \
455 ((mips_opts.isa != ISA_MIPS1) && ((CPU) != CPU_R5900))
457 /* True if mflo and mfhi can be immediately followed by instructions
458 which write to the HI and LO registers.
460 According to MIPS specifications, MIPS ISAs I, II, and III need
461 (at least) two instructions between the reads of HI/LO and
462 instructions which write them, and later ISAs do not. Contradicting
463 the MIPS specifications, some MIPS IV processor user manuals (e.g.
464 the UM for the NEC Vr5000) document needing the instructions between
465 HI/LO reads and writes, as well. Therefore, we declare only MIPS32,
466 MIPS64 and later ISAs to have the interlocks, plus any specific
467 earlier-ISA CPUs for which CPU documentation declares that the
468 instructions are really interlocked. */
469 #define hilo_interlocks \
470 (mips_opts.isa == ISA_MIPS32 \
471 || mips_opts.isa == ISA_MIPS32R2 \
472 || mips_opts.isa == ISA_MIPS64 \
473 || mips_opts.isa == ISA_MIPS64R2 \
474 || mips_opts.arch == CPU_R4010 \
475 || mips_opts.arch == CPU_R5900 \
476 || mips_opts.arch == CPU_R10000 \
477 || mips_opts.arch == CPU_R12000 \
478 || mips_opts.arch == CPU_R14000 \
479 || mips_opts.arch == CPU_R16000 \
480 || mips_opts.arch == CPU_RM7000 \
481 || mips_opts.arch == CPU_VR5500 \
482 || mips_opts.micromips \
485 /* Whether the processor uses hardware interlocks to protect reads
486 from the GPRs after they are loaded from memory, and thus does not
487 require nops to be inserted. This applies to instructions marked
488 INSN_LOAD_MEMORY_DELAY. These nops are only required at MIPS ISA
489 level I and microMIPS mode instructions are always interlocked. */
490 #define gpr_interlocks \
491 (mips_opts.isa != ISA_MIPS1 \
492 || mips_opts.arch == CPU_R3900 \
493 || mips_opts.arch == CPU_R5900 \
494 || mips_opts.micromips \
497 /* Whether the processor uses hardware interlocks to avoid delays
498 required by coprocessor instructions, and thus does not require
499 nops to be inserted. This applies to instructions marked
500 INSN_LOAD_COPROC_DELAY, INSN_COPROC_MOVE_DELAY, and to delays
501 between instructions marked INSN_WRITE_COND_CODE and ones marked
502 INSN_READ_COND_CODE. These nops are only required at MIPS ISA
503 levels I, II, and III and microMIPS mode instructions are always
505 /* Itbl support may require additional care here. */
506 #define cop_interlocks \
507 ((mips_opts.isa != ISA_MIPS1 \
508 && mips_opts.isa != ISA_MIPS2 \
509 && mips_opts.isa != ISA_MIPS3) \
510 || mips_opts.arch == CPU_R4300 \
511 || mips_opts.micromips \
514 /* Whether the processor uses hardware interlocks to protect reads
515 from coprocessor registers after they are loaded from memory, and
516 thus does not require nops to be inserted. This applies to
517 instructions marked INSN_COPROC_MEMORY_DELAY. These nops are only
518 requires at MIPS ISA level I and microMIPS mode instructions are
519 always interlocked. */
520 #define cop_mem_interlocks \
521 (mips_opts.isa != ISA_MIPS1 \
522 || mips_opts.micromips \
525 /* Is this a mfhi or mflo instruction? */
526 #define MF_HILO_INSN(PINFO) \
527 ((PINFO & INSN_READ_HI) || (PINFO & INSN_READ_LO))
529 /* Whether code compression (either of the MIPS16 or the microMIPS ASEs)
530 has been selected. This implies, in particular, that addresses of text
531 labels have their LSB set. */
532 #define HAVE_CODE_COMPRESSION \
533 ((mips_opts.mips16 | mips_opts.micromips) != 0)
535 /* The minimum and maximum signed values that can be stored in a GPR. */
536 #define GPR_SMAX ((offsetT) (((valueT) 1 << (HAVE_64BIT_GPRS ? 63 : 31)) - 1))
537 #define GPR_SMIN (-GPR_SMAX - 1)
539 /* MIPS PIC level. */
541 enum mips_pic_level mips_pic
;
543 /* 1 if we should generate 32 bit offsets from the $gp register in
544 SVR4_PIC mode. Currently has no meaning in other modes. */
545 static int mips_big_got
= 0;
547 /* 1 if trap instructions should used for overflow rather than break
549 static int mips_trap
= 0;
551 /* 1 if double width floating point constants should not be constructed
552 by assembling two single width halves into two single width floating
553 point registers which just happen to alias the double width destination
554 register. On some architectures this aliasing can be disabled by a bit
555 in the status register, and the setting of this bit cannot be determined
556 automatically at assemble time. */
557 static int mips_disable_float_construction
;
559 /* Non-zero if any .set noreorder directives were used. */
561 static int mips_any_noreorder
;
563 /* Non-zero if nops should be inserted when the register referenced in
564 an mfhi/mflo instruction is read in the next two instructions. */
565 static int mips_7000_hilo_fix
;
567 /* The size of objects in the small data section. */
568 static unsigned int g_switch_value
= 8;
569 /* Whether the -G option was used. */
570 static int g_switch_seen
= 0;
575 /* If we can determine in advance that GP optimization won't be
576 possible, we can skip the relaxation stuff that tries to produce
577 GP-relative references. This makes delay slot optimization work
580 This function can only provide a guess, but it seems to work for
581 gcc output. It needs to guess right for gcc, otherwise gcc
582 will put what it thinks is a GP-relative instruction in a branch
585 I don't know if a fix is needed for the SVR4_PIC mode. I've only
586 fixed it for the non-PIC mode. KR 95/04/07 */
587 static int nopic_need_relax (symbolS
*, int);
589 /* handle of the OPCODE hash table */
590 static struct hash_control
*op_hash
= NULL
;
592 /* The opcode hash table we use for the mips16. */
593 static struct hash_control
*mips16_op_hash
= NULL
;
595 /* The opcode hash table we use for the microMIPS ASE. */
596 static struct hash_control
*micromips_op_hash
= NULL
;
598 /* This array holds the chars that always start a comment. If the
599 pre-processor is disabled, these aren't very useful */
600 const char comment_chars
[] = "#";
602 /* This array holds the chars that only start a comment at the beginning of
603 a line. If the line seems to have the form '# 123 filename'
604 .line and .file directives will appear in the pre-processed output */
605 /* Note that input_file.c hand checks for '#' at the beginning of the
606 first line of the input file. This is because the compiler outputs
607 #NO_APP at the beginning of its output. */
608 /* Also note that C style comments are always supported. */
609 const char line_comment_chars
[] = "#";
611 /* This array holds machine specific line separator characters. */
612 const char line_separator_chars
[] = ";";
614 /* Chars that can be used to separate mant from exp in floating point nums */
615 const char EXP_CHARS
[] = "eE";
617 /* Chars that mean this number is a floating point constant */
620 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
622 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
623 changed in read.c . Ideally it shouldn't have to know about it at all,
624 but nothing is ideal around here.
627 static char *insn_error
;
629 static int auto_align
= 1;
631 /* When outputting SVR4 PIC code, the assembler needs to know the
632 offset in the stack frame from which to restore the $gp register.
633 This is set by the .cprestore pseudo-op, and saved in this
635 static offsetT mips_cprestore_offset
= -1;
637 /* Similar for NewABI PIC code, where $gp is callee-saved. NewABI has some
638 more optimizations, it can use a register value instead of a memory-saved
639 offset and even an other register than $gp as global pointer. */
640 static offsetT mips_cpreturn_offset
= -1;
641 static int mips_cpreturn_register
= -1;
642 static int mips_gp_register
= GP
;
643 static int mips_gprel_offset
= 0;
645 /* Whether mips_cprestore_offset has been set in the current function
646 (or whether it has already been warned about, if not). */
647 static int mips_cprestore_valid
= 0;
649 /* This is the register which holds the stack frame, as set by the
650 .frame pseudo-op. This is needed to implement .cprestore. */
651 static int mips_frame_reg
= SP
;
653 /* Whether mips_frame_reg has been set in the current function
654 (or whether it has already been warned about, if not). */
655 static int mips_frame_reg_valid
= 0;
657 /* To output NOP instructions correctly, we need to keep information
658 about the previous two instructions. */
660 /* Whether we are optimizing. The default value of 2 means to remove
661 unneeded NOPs and swap branch instructions when possible. A value
662 of 1 means to not swap branches. A value of 0 means to always
664 static int mips_optimize
= 2;
666 /* Debugging level. -g sets this to 2. -gN sets this to N. -g0 is
667 equivalent to seeing no -g option at all. */
668 static int mips_debug
= 0;
670 /* The maximum number of NOPs needed to avoid the VR4130 mflo/mfhi errata. */
671 #define MAX_VR4130_NOPS 4
673 /* The maximum number of NOPs needed to fill delay slots. */
674 #define MAX_DELAY_NOPS 2
676 /* The maximum number of NOPs needed for any purpose. */
679 /* A list of previous instructions, with index 0 being the most recent.
680 We need to look back MAX_NOPS instructions when filling delay slots
681 or working around processor errata. We need to look back one
682 instruction further if we're thinking about using history[0] to
683 fill a branch delay slot. */
684 static struct mips_cl_insn history
[1 + MAX_NOPS
];
686 /* Nop instructions used by emit_nop. */
687 static struct mips_cl_insn nop_insn
;
688 static struct mips_cl_insn mips16_nop_insn
;
689 static struct mips_cl_insn micromips_nop16_insn
;
690 static struct mips_cl_insn micromips_nop32_insn
;
692 /* The appropriate nop for the current mode. */
693 #define NOP_INSN (mips_opts.mips16 \
695 : (mips_opts.micromips \
696 ? (mips_opts.insn32 \
697 ? µmips_nop32_insn \
698 : µmips_nop16_insn) \
701 /* The size of NOP_INSN in bytes. */
702 #define NOP_INSN_SIZE ((mips_opts.mips16 \
703 || (mips_opts.micromips && !mips_opts.insn32)) \
706 /* If this is set, it points to a frag holding nop instructions which
707 were inserted before the start of a noreorder section. If those
708 nops turn out to be unnecessary, the size of the frag can be
710 static fragS
*prev_nop_frag
;
712 /* The number of nop instructions we created in prev_nop_frag. */
713 static int prev_nop_frag_holds
;
715 /* The number of nop instructions that we know we need in
717 static int prev_nop_frag_required
;
719 /* The number of instructions we've seen since prev_nop_frag. */
720 static int prev_nop_frag_since
;
722 /* Relocations against symbols are sometimes done in two parts, with a HI
723 relocation and a LO relocation. Each relocation has only 16 bits of
724 space to store an addend. This means that in order for the linker to
725 handle carries correctly, it must be able to locate both the HI and
726 the LO relocation. This means that the relocations must appear in
727 order in the relocation table.
729 In order to implement this, we keep track of each unmatched HI
730 relocation. We then sort them so that they immediately precede the
731 corresponding LO relocation. */
736 struct mips_hi_fixup
*next
;
739 /* The section this fixup is in. */
743 /* The list of unmatched HI relocs. */
745 static struct mips_hi_fixup
*mips_hi_fixup_list
;
747 /* The frag containing the last explicit relocation operator.
748 Null if explicit relocations have not been used. */
750 static fragS
*prev_reloc_op_frag
;
752 /* Map normal MIPS register numbers to mips16 register numbers. */
754 #define X ILLEGAL_REG
755 static const int mips32_to_16_reg_map
[] =
757 X
, X
, 2, 3, 4, 5, 6, 7,
758 X
, X
, X
, X
, X
, X
, X
, X
,
759 0, 1, X
, X
, X
, X
, X
, X
,
760 X
, X
, X
, X
, X
, X
, X
, X
764 /* Map mips16 register numbers to normal MIPS register numbers. */
766 static const unsigned int mips16_to_32_reg_map
[] =
768 16, 17, 2, 3, 4, 5, 6, 7
771 /* Map normal MIPS register numbers to microMIPS register numbers. */
773 #define mips32_to_micromips_reg_b_map mips32_to_16_reg_map
774 #define mips32_to_micromips_reg_c_map mips32_to_16_reg_map
775 #define mips32_to_micromips_reg_d_map mips32_to_16_reg_map
776 #define mips32_to_micromips_reg_e_map mips32_to_16_reg_map
777 #define mips32_to_micromips_reg_f_map mips32_to_16_reg_map
778 #define mips32_to_micromips_reg_g_map mips32_to_16_reg_map
779 #define mips32_to_micromips_reg_l_map mips32_to_16_reg_map
781 #define X ILLEGAL_REG
782 /* reg type m: 0, 17, 2, 3, 16, 18, 19, 20. */
783 static const int mips32_to_micromips_reg_m_map
[] =
785 0, X
, 2, 3, X
, X
, X
, X
,
786 X
, X
, X
, X
, X
, X
, X
, X
,
787 4, 1, 5, 6, 7, X
, X
, X
,
788 X
, X
, X
, X
, X
, X
, X
, X
791 /* reg type q: 0, 2-7. 17. */
792 static const int mips32_to_micromips_reg_q_map
[] =
794 0, X
, 2, 3, 4, 5, 6, 7,
795 X
, X
, X
, X
, X
, X
, X
, X
,
796 X
, 1, X
, X
, X
, X
, X
, X
,
797 X
, X
, X
, X
, X
, X
, X
, X
800 #define mips32_to_micromips_reg_n_map mips32_to_micromips_reg_m_map
803 /* Map microMIPS register numbers to normal MIPS register numbers. */
805 #define micromips_to_32_reg_b_map mips16_to_32_reg_map
806 #define micromips_to_32_reg_c_map mips16_to_32_reg_map
807 #define micromips_to_32_reg_d_map mips16_to_32_reg_map
808 #define micromips_to_32_reg_e_map mips16_to_32_reg_map
809 #define micromips_to_32_reg_f_map mips16_to_32_reg_map
810 #define micromips_to_32_reg_g_map mips16_to_32_reg_map
812 /* The microMIPS registers with type h. */
813 static const unsigned int micromips_to_32_reg_h_map1
[] =
815 5, 5, 6, 4, 4, 4, 4, 4
817 static const unsigned int micromips_to_32_reg_h_map2
[] =
819 6, 7, 7, 21, 22, 5, 6, 7
822 #define micromips_to_32_reg_l_map mips16_to_32_reg_map
824 /* The microMIPS registers with type m. */
825 static const unsigned int micromips_to_32_reg_m_map
[] =
827 0, 17, 2, 3, 16, 18, 19, 20
830 #define micromips_to_32_reg_n_map micromips_to_32_reg_m_map
832 /* The microMIPS registers with type q. */
833 static const unsigned int micromips_to_32_reg_q_map
[] =
835 0, 17, 2, 3, 4, 5, 6, 7
838 /* microMIPS imm type B. */
839 static const int micromips_imm_b_map
[] =
841 1, 4, 8, 12, 16, 20, 24, -1
844 /* microMIPS imm type C. */
845 static const int micromips_imm_c_map
[] =
847 128, 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 255, 32768, 65535
850 /* Classifies the kind of instructions we're interested in when
851 implementing -mfix-vr4120. */
852 enum fix_vr4120_class
860 NUM_FIX_VR4120_CLASSES
863 /* ...likewise -mfix-loongson2f-jump. */
864 static bfd_boolean mips_fix_loongson2f_jump
;
866 /* ...likewise -mfix-loongson2f-nop. */
867 static bfd_boolean mips_fix_loongson2f_nop
;
869 /* True if -mfix-loongson2f-nop or -mfix-loongson2f-jump passed. */
870 static bfd_boolean mips_fix_loongson2f
;
872 /* Given two FIX_VR4120_* values X and Y, bit Y of element X is set if
873 there must be at least one other instruction between an instruction
874 of type X and an instruction of type Y. */
875 static unsigned int vr4120_conflicts
[NUM_FIX_VR4120_CLASSES
];
877 /* True if -mfix-vr4120 is in force. */
878 static int mips_fix_vr4120
;
880 /* ...likewise -mfix-vr4130. */
881 static int mips_fix_vr4130
;
883 /* ...likewise -mfix-24k. */
884 static int mips_fix_24k
;
886 /* ...likewise -mfix-cn63xxp1 */
887 static bfd_boolean mips_fix_cn63xxp1
;
889 /* We don't relax branches by default, since this causes us to expand
890 `la .l2 - .l1' if there's a branch between .l1 and .l2, because we
891 fail to compute the offset before expanding the macro to the most
892 efficient expansion. */
894 static int mips_relax_branch
;
896 /* The expansion of many macros depends on the type of symbol that
897 they refer to. For example, when generating position-dependent code,
898 a macro that refers to a symbol may have two different expansions,
899 one which uses GP-relative addresses and one which uses absolute
900 addresses. When generating SVR4-style PIC, a macro may have
901 different expansions for local and global symbols.
903 We handle these situations by generating both sequences and putting
904 them in variant frags. In position-dependent code, the first sequence
905 will be the GP-relative one and the second sequence will be the
906 absolute one. In SVR4 PIC, the first sequence will be for global
907 symbols and the second will be for local symbols.
909 The frag's "subtype" is RELAX_ENCODE (FIRST, SECOND), where FIRST and
910 SECOND are the lengths of the two sequences in bytes. These fields
911 can be extracted using RELAX_FIRST() and RELAX_SECOND(). In addition,
912 the subtype has the following flags:
915 Set if it has been decided that we should use the second
916 sequence instead of the first.
919 Set in the first variant frag if the macro's second implementation
920 is longer than its first. This refers to the macro as a whole,
921 not an individual relaxation.
924 Set in the first variant frag if the macro appeared in a .set nomacro
925 block and if one alternative requires a warning but the other does not.
928 Like RELAX_NOMACRO, but indicates that the macro appears in a branch
931 RELAX_DELAY_SLOT_16BIT
932 Like RELAX_DELAY_SLOT, but indicates that the delay slot requires a
935 RELAX_DELAY_SLOT_SIZE_FIRST
936 Like RELAX_DELAY_SLOT, but indicates that the first implementation of
937 the macro is of the wrong size for the branch delay slot.
939 RELAX_DELAY_SLOT_SIZE_SECOND
940 Like RELAX_DELAY_SLOT, but indicates that the second implementation of
941 the macro is of the wrong size for the branch delay slot.
943 The frag's "opcode" points to the first fixup for relaxable code.
945 Relaxable macros are generated using a sequence such as:
947 relax_start (SYMBOL);
948 ... generate first expansion ...
950 ... generate second expansion ...
953 The code and fixups for the unwanted alternative are discarded
954 by md_convert_frag. */
955 #define RELAX_ENCODE(FIRST, SECOND) (((FIRST) << 8) | (SECOND))
957 #define RELAX_FIRST(X) (((X) >> 8) & 0xff)
958 #define RELAX_SECOND(X) ((X) & 0xff)
959 #define RELAX_USE_SECOND 0x10000
960 #define RELAX_SECOND_LONGER 0x20000
961 #define RELAX_NOMACRO 0x40000
962 #define RELAX_DELAY_SLOT 0x80000
963 #define RELAX_DELAY_SLOT_16BIT 0x100000
964 #define RELAX_DELAY_SLOT_SIZE_FIRST 0x200000
965 #define RELAX_DELAY_SLOT_SIZE_SECOND 0x400000
967 /* Branch without likely bit. If label is out of range, we turn:
969 beq reg1, reg2, label
979 with the following opcode replacements:
986 bltzal <-> bgezal (with jal label instead of j label)
988 Even though keeping the delay slot instruction in the delay slot of
989 the branch would be more efficient, it would be very tricky to do
990 correctly, because we'd have to introduce a variable frag *after*
991 the delay slot instruction, and expand that instead. Let's do it
992 the easy way for now, even if the branch-not-taken case now costs
993 one additional instruction. Out-of-range branches are not supposed
994 to be common, anyway.
996 Branch likely. If label is out of range, we turn:
998 beql reg1, reg2, label
999 delay slot (annulled if branch not taken)
1008 delay slot (executed only if branch taken)
1011 It would be possible to generate a shorter sequence by losing the
1012 likely bit, generating something like:
1017 delay slot (executed only if branch taken)
1029 bltzall -> bgezal (with jal label instead of j label)
1030 bgezall -> bltzal (ditto)
1033 but it's not clear that it would actually improve performance. */
1034 #define RELAX_BRANCH_ENCODE(at, uncond, likely, link, toofar) \
1035 ((relax_substateT) \
1038 | ((toofar) ? 0x20 : 0) \
1039 | ((link) ? 0x40 : 0) \
1040 | ((likely) ? 0x80 : 0) \
1041 | ((uncond) ? 0x100 : 0)))
1042 #define RELAX_BRANCH_P(i) (((i) & 0xf0000000) == 0xc0000000)
1043 #define RELAX_BRANCH_UNCOND(i) (((i) & 0x100) != 0)
1044 #define RELAX_BRANCH_LIKELY(i) (((i) & 0x80) != 0)
1045 #define RELAX_BRANCH_LINK(i) (((i) & 0x40) != 0)
1046 #define RELAX_BRANCH_TOOFAR(i) (((i) & 0x20) != 0)
1047 #define RELAX_BRANCH_AT(i) ((i) & 0x1f)
1049 /* For mips16 code, we use an entirely different form of relaxation.
1050 mips16 supports two versions of most instructions which take
1051 immediate values: a small one which takes some small value, and a
1052 larger one which takes a 16 bit value. Since branches also follow
1053 this pattern, relaxing these values is required.
1055 We can assemble both mips16 and normal MIPS code in a single
1056 object. Therefore, we need to support this type of relaxation at
1057 the same time that we support the relaxation described above. We
1058 use the high bit of the subtype field to distinguish these cases.
1060 The information we store for this type of relaxation is the
1061 argument code found in the opcode file for this relocation, whether
1062 the user explicitly requested a small or extended form, and whether
1063 the relocation is in a jump or jal delay slot. That tells us the
1064 size of the value, and how it should be stored. We also store
1065 whether the fragment is considered to be extended or not. We also
1066 store whether this is known to be a branch to a different section,
1067 whether we have tried to relax this frag yet, and whether we have
1068 ever extended a PC relative fragment because of a shift count. */
1069 #define RELAX_MIPS16_ENCODE(type, small, ext, dslot, jal_dslot) \
1072 | ((small) ? 0x100 : 0) \
1073 | ((ext) ? 0x200 : 0) \
1074 | ((dslot) ? 0x400 : 0) \
1075 | ((jal_dslot) ? 0x800 : 0))
1076 #define RELAX_MIPS16_P(i) (((i) & 0xc0000000) == 0x80000000)
1077 #define RELAX_MIPS16_TYPE(i) ((i) & 0xff)
1078 #define RELAX_MIPS16_USER_SMALL(i) (((i) & 0x100) != 0)
1079 #define RELAX_MIPS16_USER_EXT(i) (((i) & 0x200) != 0)
1080 #define RELAX_MIPS16_DSLOT(i) (((i) & 0x400) != 0)
1081 #define RELAX_MIPS16_JAL_DSLOT(i) (((i) & 0x800) != 0)
1082 #define RELAX_MIPS16_EXTENDED(i) (((i) & 0x1000) != 0)
1083 #define RELAX_MIPS16_MARK_EXTENDED(i) ((i) | 0x1000)
1084 #define RELAX_MIPS16_CLEAR_EXTENDED(i) ((i) &~ 0x1000)
1085 #define RELAX_MIPS16_LONG_BRANCH(i) (((i) & 0x2000) != 0)
1086 #define RELAX_MIPS16_MARK_LONG_BRANCH(i) ((i) | 0x2000)
1087 #define RELAX_MIPS16_CLEAR_LONG_BRANCH(i) ((i) &~ 0x2000)
1089 /* For microMIPS code, we use relaxation similar to one we use for
1090 MIPS16 code. Some instructions that take immediate values support
1091 two encodings: a small one which takes some small value, and a
1092 larger one which takes a 16 bit value. As some branches also follow
1093 this pattern, relaxing these values is required.
1095 We can assemble both microMIPS and normal MIPS code in a single
1096 object. Therefore, we need to support this type of relaxation at
1097 the same time that we support the relaxation described above. We
1098 use one of the high bits of the subtype field to distinguish these
1101 The information we store for this type of relaxation is the argument
1102 code found in the opcode file for this relocation, the register
1103 selected as the assembler temporary, whether the branch is
1104 unconditional, whether it is compact, whether it stores the link
1105 address implicitly in $ra, whether relaxation of out-of-range 32-bit
1106 branches to a sequence of instructions is enabled, and whether the
1107 displacement of a branch is too large to fit as an immediate argument
1108 of a 16-bit and a 32-bit branch, respectively. */
1109 #define RELAX_MICROMIPS_ENCODE(type, at, uncond, compact, link, \
1110 relax32, toofar16, toofar32) \
1113 | (((at) & 0x1f) << 8) \
1114 | ((uncond) ? 0x2000 : 0) \
1115 | ((compact) ? 0x4000 : 0) \
1116 | ((link) ? 0x8000 : 0) \
1117 | ((relax32) ? 0x10000 : 0) \
1118 | ((toofar16) ? 0x20000 : 0) \
1119 | ((toofar32) ? 0x40000 : 0))
1120 #define RELAX_MICROMIPS_P(i) (((i) & 0xc0000000) == 0x40000000)
1121 #define RELAX_MICROMIPS_TYPE(i) ((i) & 0xff)
1122 #define RELAX_MICROMIPS_AT(i) (((i) >> 8) & 0x1f)
1123 #define RELAX_MICROMIPS_UNCOND(i) (((i) & 0x2000) != 0)
1124 #define RELAX_MICROMIPS_COMPACT(i) (((i) & 0x4000) != 0)
1125 #define RELAX_MICROMIPS_LINK(i) (((i) & 0x8000) != 0)
1126 #define RELAX_MICROMIPS_RELAX32(i) (((i) & 0x10000) != 0)
1128 #define RELAX_MICROMIPS_TOOFAR16(i) (((i) & 0x20000) != 0)
1129 #define RELAX_MICROMIPS_MARK_TOOFAR16(i) ((i) | 0x20000)
1130 #define RELAX_MICROMIPS_CLEAR_TOOFAR16(i) ((i) & ~0x20000)
1131 #define RELAX_MICROMIPS_TOOFAR32(i) (((i) & 0x40000) != 0)
1132 #define RELAX_MICROMIPS_MARK_TOOFAR32(i) ((i) | 0x40000)
1133 #define RELAX_MICROMIPS_CLEAR_TOOFAR32(i) ((i) & ~0x40000)
1135 /* Sign-extend 16-bit value X. */
1136 #define SEXT_16BIT(X) ((((X) + 0x8000) & 0xffff) - 0x8000)
1138 /* Is the given value a sign-extended 32-bit value? */
1139 #define IS_SEXT_32BIT_NUM(x) \
1140 (((x) &~ (offsetT) 0x7fffffff) == 0 \
1141 || (((x) &~ (offsetT) 0x7fffffff) == ~ (offsetT) 0x7fffffff))
1143 /* Is the given value a sign-extended 16-bit value? */
1144 #define IS_SEXT_16BIT_NUM(x) \
1145 (((x) &~ (offsetT) 0x7fff) == 0 \
1146 || (((x) &~ (offsetT) 0x7fff) == ~ (offsetT) 0x7fff))
1148 /* Is the given value a sign-extended 12-bit value? */
1149 #define IS_SEXT_12BIT_NUM(x) \
1150 (((((x) & 0xfff) ^ 0x800LL) - 0x800LL) == (x))
1152 /* Is the given value a sign-extended 9-bit value? */
1153 #define IS_SEXT_9BIT_NUM(x) \
1154 (((((x) & 0x1ff) ^ 0x100LL) - 0x100LL) == (x))
1156 /* Is the given value a zero-extended 32-bit value? Or a negated one? */
1157 #define IS_ZEXT_32BIT_NUM(x) \
1158 (((x) &~ (offsetT) 0xffffffff) == 0 \
1159 || (((x) &~ (offsetT) 0xffffffff) == ~ (offsetT) 0xffffffff))
1161 /* Replace bits MASK << SHIFT of STRUCT with the equivalent bits in
1162 VALUE << SHIFT. VALUE is evaluated exactly once. */
1163 #define INSERT_BITS(STRUCT, VALUE, MASK, SHIFT) \
1164 (STRUCT) = (((STRUCT) & ~((MASK) << (SHIFT))) \
1165 | (((VALUE) & (MASK)) << (SHIFT)))
1167 /* Extract bits MASK << SHIFT from STRUCT and shift them right
1169 #define EXTRACT_BITS(STRUCT, MASK, SHIFT) \
1170 (((STRUCT) >> (SHIFT)) & (MASK))
1172 /* Change INSN's opcode so that the operand given by FIELD has value VALUE.
1173 INSN is a mips_cl_insn structure and VALUE is evaluated exactly once.
1175 include/opcode/mips.h specifies operand fields using the macros
1176 OP_MASK_<FIELD> and OP_SH_<FIELD>. The MIPS16 equivalents start
1177 with "MIPS16OP" instead of "OP". */
1178 #define INSERT_OPERAND(MICROMIPS, FIELD, INSN, VALUE) \
1181 INSERT_BITS ((INSN).insn_opcode, VALUE, \
1182 OP_MASK_##FIELD, OP_SH_##FIELD); \
1184 INSERT_BITS ((INSN).insn_opcode, VALUE, \
1185 MICROMIPSOP_MASK_##FIELD, MICROMIPSOP_SH_##FIELD); \
1187 #define MIPS16_INSERT_OPERAND(FIELD, INSN, VALUE) \
1188 INSERT_BITS ((INSN).insn_opcode, VALUE, \
1189 MIPS16OP_MASK_##FIELD, MIPS16OP_SH_##FIELD)
1191 /* Extract the operand given by FIELD from mips_cl_insn INSN. */
1192 #define EXTRACT_OPERAND(MICROMIPS, FIELD, INSN) \
1194 ? EXTRACT_BITS ((INSN).insn_opcode, OP_MASK_##FIELD, OP_SH_##FIELD) \
1195 : EXTRACT_BITS ((INSN).insn_opcode, \
1196 MICROMIPSOP_MASK_##FIELD, MICROMIPSOP_SH_##FIELD))
1197 #define MIPS16_EXTRACT_OPERAND(FIELD, INSN) \
1198 EXTRACT_BITS ((INSN).insn_opcode, \
1199 MIPS16OP_MASK_##FIELD, \
1200 MIPS16OP_SH_##FIELD)
1202 /* The MIPS16 EXTEND opcode, shifted left 16 places. */
1203 #define MIPS16_EXTEND (0xf000U << 16)
1205 /* Whether or not we are emitting a branch-likely macro. */
1206 static bfd_boolean emit_branch_likely_macro
= FALSE
;
1208 /* Global variables used when generating relaxable macros. See the
1209 comment above RELAX_ENCODE for more details about how relaxation
1212 /* 0 if we're not emitting a relaxable macro.
1213 1 if we're emitting the first of the two relaxation alternatives.
1214 2 if we're emitting the second alternative. */
1217 /* The first relaxable fixup in the current frag. (In other words,
1218 the first fixup that refers to relaxable code.) */
1221 /* sizes[0] says how many bytes of the first alternative are stored in
1222 the current frag. Likewise sizes[1] for the second alternative. */
1223 unsigned int sizes
[2];
1225 /* The symbol on which the choice of sequence depends. */
1229 /* Global variables used to decide whether a macro needs a warning. */
1231 /* True if the macro is in a branch delay slot. */
1232 bfd_boolean delay_slot_p
;
1234 /* Set to the length in bytes required if the macro is in a delay slot
1235 that requires a specific length of instruction, otherwise zero. */
1236 unsigned int delay_slot_length
;
1238 /* For relaxable macros, sizes[0] is the length of the first alternative
1239 in bytes and sizes[1] is the length of the second alternative.
1240 For non-relaxable macros, both elements give the length of the
1242 unsigned int sizes
[2];
1244 /* For relaxable macros, first_insn_sizes[0] is the length of the first
1245 instruction of the first alternative in bytes and first_insn_sizes[1]
1246 is the length of the first instruction of the second alternative.
1247 For non-relaxable macros, both elements give the length of the first
1248 instruction in bytes.
1250 Set to zero if we haven't yet seen the first instruction. */
1251 unsigned int first_insn_sizes
[2];
1253 /* For relaxable macros, insns[0] is the number of instructions for the
1254 first alternative and insns[1] is the number of instructions for the
1257 For non-relaxable macros, both elements give the number of
1258 instructions for the macro. */
1259 unsigned int insns
[2];
1261 /* The first variant frag for this macro. */
1263 } mips_macro_warning
;
1265 /* Prototypes for static functions. */
1267 enum mips_regclass
{ MIPS_GR_REG
, MIPS_FP_REG
, MIPS16_REG
};
1269 static void append_insn
1270 (struct mips_cl_insn
*, expressionS
*, bfd_reloc_code_real_type
*,
1271 bfd_boolean expansionp
);
1272 static void mips_no_prev_insn (void);
1273 static void macro_build (expressionS
*, const char *, const char *, ...);
1274 static void mips16_macro_build
1275 (expressionS
*, const char *, const char *, va_list *);
1276 static void load_register (int, expressionS
*, int);
1277 static void macro_start (void);
1278 static void macro_end (void);
1279 static void macro (struct mips_cl_insn
*ip
, char *str
);
1280 static void mips16_macro (struct mips_cl_insn
* ip
);
1281 static void mips_ip (char *str
, struct mips_cl_insn
* ip
);
1282 static void mips16_ip (char *str
, struct mips_cl_insn
* ip
);
1283 static void mips16_immed
1284 (char *, unsigned int, int, bfd_reloc_code_real_type
, offsetT
,
1285 unsigned int, unsigned long *);
1286 static size_t my_getSmallExpression
1287 (expressionS
*, bfd_reloc_code_real_type
*, char *);
1288 static void my_getExpression (expressionS
*, char *);
1289 static void s_align (int);
1290 static void s_change_sec (int);
1291 static void s_change_section (int);
1292 static void s_cons (int);
1293 static void s_float_cons (int);
1294 static void s_mips_globl (int);
1295 static void s_option (int);
1296 static void s_mipsset (int);
1297 static void s_abicalls (int);
1298 static void s_cpload (int);
1299 static void s_cpsetup (int);
1300 static void s_cplocal (int);
1301 static void s_cprestore (int);
1302 static void s_cpreturn (int);
1303 static void s_dtprelword (int);
1304 static void s_dtpreldword (int);
1305 static void s_tprelword (int);
1306 static void s_tpreldword (int);
1307 static void s_gpvalue (int);
1308 static void s_gpword (int);
1309 static void s_gpdword (int);
1310 static void s_ehword (int);
1311 static void s_cpadd (int);
1312 static void s_insn (int);
1313 static void md_obj_begin (void);
1314 static void md_obj_end (void);
1315 static void s_mips_ent (int);
1316 static void s_mips_end (int);
1317 static void s_mips_frame (int);
1318 static void s_mips_mask (int reg_type
);
1319 static void s_mips_stab (int);
1320 static void s_mips_weakext (int);
1321 static void s_mips_file (int);
1322 static void s_mips_loc (int);
1323 static bfd_boolean
pic_need_relax (symbolS
*, asection
*);
1324 static int relaxed_branch_length (fragS
*, asection
*, int);
1325 static int validate_mips_insn (const struct mips_opcode
*);
1326 static int validate_micromips_insn (const struct mips_opcode
*);
1327 static int relaxed_micromips_16bit_branch_length (fragS
*, asection
*, int);
1328 static int relaxed_micromips_32bit_branch_length (fragS
*, asection
*, int);
1330 /* Table and functions used to map between CPU/ISA names, and
1331 ISA levels, and CPU numbers. */
1333 struct mips_cpu_info
1335 const char *name
; /* CPU or ISA name. */
1336 int flags
; /* MIPS_CPU_* flags. */
1337 int ase
; /* Set of ASEs implemented by the CPU. */
1338 int isa
; /* ISA level. */
1339 int cpu
; /* CPU number (default CPU if ISA). */
1342 #define MIPS_CPU_IS_ISA 0x0001 /* Is this an ISA? (If 0, a CPU.) */
1344 static const struct mips_cpu_info
*mips_parse_cpu (const char *, const char *);
1345 static const struct mips_cpu_info
*mips_cpu_info_from_isa (int);
1346 static const struct mips_cpu_info
*mips_cpu_info_from_arch (int);
1348 /* Command-line options. */
1349 const char *md_shortopts
= "O::g::G:";
1353 OPTION_MARCH
= OPTION_MD_BASE
,
1377 OPTION_NO_SMARTMIPS
,
1383 OPTION_NO_MICROMIPS
,
1386 OPTION_COMPAT_ARCH_BASE
,
1395 OPTION_M7000_HILO_FIX
,
1396 OPTION_MNO_7000_HILO_FIX
,
1399 OPTION_FIX_LOONGSON2F_JUMP
,
1400 OPTION_NO_FIX_LOONGSON2F_JUMP
,
1401 OPTION_FIX_LOONGSON2F_NOP
,
1402 OPTION_NO_FIX_LOONGSON2F_NOP
,
1404 OPTION_NO_FIX_VR4120
,
1406 OPTION_NO_FIX_VR4130
,
1407 OPTION_FIX_CN63XXP1
,
1408 OPTION_NO_FIX_CN63XXP1
,
1415 OPTION_CONSTRUCT_FLOATS
,
1416 OPTION_NO_CONSTRUCT_FLOATS
,
1419 OPTION_RELAX_BRANCH
,
1420 OPTION_NO_RELAX_BRANCH
,
1429 OPTION_SINGLE_FLOAT
,
1430 OPTION_DOUBLE_FLOAT
,
1443 OPTION_MVXWORKS_PIC
,
1447 struct option md_longopts
[] =
1449 /* Options which specify architecture. */
1450 {"march", required_argument
, NULL
, OPTION_MARCH
},
1451 {"mtune", required_argument
, NULL
, OPTION_MTUNE
},
1452 {"mips0", no_argument
, NULL
, OPTION_MIPS1
},
1453 {"mips1", no_argument
, NULL
, OPTION_MIPS1
},
1454 {"mips2", no_argument
, NULL
, OPTION_MIPS2
},
1455 {"mips3", no_argument
, NULL
, OPTION_MIPS3
},
1456 {"mips4", no_argument
, NULL
, OPTION_MIPS4
},
1457 {"mips5", no_argument
, NULL
, OPTION_MIPS5
},
1458 {"mips32", no_argument
, NULL
, OPTION_MIPS32
},
1459 {"mips64", no_argument
, NULL
, OPTION_MIPS64
},
1460 {"mips32r2", no_argument
, NULL
, OPTION_MIPS32R2
},
1461 {"mips64r2", no_argument
, NULL
, OPTION_MIPS64R2
},
1463 /* Options which specify Application Specific Extensions (ASEs). */
1464 {"mips16", no_argument
, NULL
, OPTION_MIPS16
},
1465 {"no-mips16", no_argument
, NULL
, OPTION_NO_MIPS16
},
1466 {"mips3d", no_argument
, NULL
, OPTION_MIPS3D
},
1467 {"no-mips3d", no_argument
, NULL
, OPTION_NO_MIPS3D
},
1468 {"mdmx", no_argument
, NULL
, OPTION_MDMX
},
1469 {"no-mdmx", no_argument
, NULL
, OPTION_NO_MDMX
},
1470 {"mdsp", no_argument
, NULL
, OPTION_DSP
},
1471 {"mno-dsp", no_argument
, NULL
, OPTION_NO_DSP
},
1472 {"mmt", no_argument
, NULL
, OPTION_MT
},
1473 {"mno-mt", no_argument
, NULL
, OPTION_NO_MT
},
1474 {"msmartmips", no_argument
, NULL
, OPTION_SMARTMIPS
},
1475 {"mno-smartmips", no_argument
, NULL
, OPTION_NO_SMARTMIPS
},
1476 {"mdspr2", no_argument
, NULL
, OPTION_DSPR2
},
1477 {"mno-dspr2", no_argument
, NULL
, OPTION_NO_DSPR2
},
1478 {"meva", no_argument
, NULL
, OPTION_EVA
},
1479 {"mno-eva", no_argument
, NULL
, OPTION_NO_EVA
},
1480 {"mmicromips", no_argument
, NULL
, OPTION_MICROMIPS
},
1481 {"mno-micromips", no_argument
, NULL
, OPTION_NO_MICROMIPS
},
1482 {"mmcu", no_argument
, NULL
, OPTION_MCU
},
1483 {"mno-mcu", no_argument
, NULL
, OPTION_NO_MCU
},
1484 {"mvirt", no_argument
, NULL
, OPTION_VIRT
},
1485 {"mno-virt", no_argument
, NULL
, OPTION_NO_VIRT
},
1487 /* Old-style architecture options. Don't add more of these. */
1488 {"m4650", no_argument
, NULL
, OPTION_M4650
},
1489 {"no-m4650", no_argument
, NULL
, OPTION_NO_M4650
},
1490 {"m4010", no_argument
, NULL
, OPTION_M4010
},
1491 {"no-m4010", no_argument
, NULL
, OPTION_NO_M4010
},
1492 {"m4100", no_argument
, NULL
, OPTION_M4100
},
1493 {"no-m4100", no_argument
, NULL
, OPTION_NO_M4100
},
1494 {"m3900", no_argument
, NULL
, OPTION_M3900
},
1495 {"no-m3900", no_argument
, NULL
, OPTION_NO_M3900
},
1497 /* Options which enable bug fixes. */
1498 {"mfix7000", no_argument
, NULL
, OPTION_M7000_HILO_FIX
},
1499 {"no-fix-7000", no_argument
, NULL
, OPTION_MNO_7000_HILO_FIX
},
1500 {"mno-fix7000", no_argument
, NULL
, OPTION_MNO_7000_HILO_FIX
},
1501 {"mfix-loongson2f-jump", no_argument
, NULL
, OPTION_FIX_LOONGSON2F_JUMP
},
1502 {"mno-fix-loongson2f-jump", no_argument
, NULL
, OPTION_NO_FIX_LOONGSON2F_JUMP
},
1503 {"mfix-loongson2f-nop", no_argument
, NULL
, OPTION_FIX_LOONGSON2F_NOP
},
1504 {"mno-fix-loongson2f-nop", no_argument
, NULL
, OPTION_NO_FIX_LOONGSON2F_NOP
},
1505 {"mfix-vr4120", no_argument
, NULL
, OPTION_FIX_VR4120
},
1506 {"mno-fix-vr4120", no_argument
, NULL
, OPTION_NO_FIX_VR4120
},
1507 {"mfix-vr4130", no_argument
, NULL
, OPTION_FIX_VR4130
},
1508 {"mno-fix-vr4130", no_argument
, NULL
, OPTION_NO_FIX_VR4130
},
1509 {"mfix-24k", no_argument
, NULL
, OPTION_FIX_24K
},
1510 {"mno-fix-24k", no_argument
, NULL
, OPTION_NO_FIX_24K
},
1511 {"mfix-cn63xxp1", no_argument
, NULL
, OPTION_FIX_CN63XXP1
},
1512 {"mno-fix-cn63xxp1", no_argument
, NULL
, OPTION_NO_FIX_CN63XXP1
},
1514 /* Miscellaneous options. */
1515 {"trap", no_argument
, NULL
, OPTION_TRAP
},
1516 {"no-break", no_argument
, NULL
, OPTION_TRAP
},
1517 {"break", no_argument
, NULL
, OPTION_BREAK
},
1518 {"no-trap", no_argument
, NULL
, OPTION_BREAK
},
1519 {"EB", no_argument
, NULL
, OPTION_EB
},
1520 {"EL", no_argument
, NULL
, OPTION_EL
},
1521 {"mfp32", no_argument
, NULL
, OPTION_FP32
},
1522 {"mgp32", no_argument
, NULL
, OPTION_GP32
},
1523 {"construct-floats", no_argument
, NULL
, OPTION_CONSTRUCT_FLOATS
},
1524 {"no-construct-floats", no_argument
, NULL
, OPTION_NO_CONSTRUCT_FLOATS
},
1525 {"mfp64", no_argument
, NULL
, OPTION_FP64
},
1526 {"mgp64", no_argument
, NULL
, OPTION_GP64
},
1527 {"relax-branch", no_argument
, NULL
, OPTION_RELAX_BRANCH
},
1528 {"no-relax-branch", no_argument
, NULL
, OPTION_NO_RELAX_BRANCH
},
1529 {"minsn32", no_argument
, NULL
, OPTION_INSN32
},
1530 {"mno-insn32", no_argument
, NULL
, OPTION_NO_INSN32
},
1531 {"mshared", no_argument
, NULL
, OPTION_MSHARED
},
1532 {"mno-shared", no_argument
, NULL
, OPTION_MNO_SHARED
},
1533 {"msym32", no_argument
, NULL
, OPTION_MSYM32
},
1534 {"mno-sym32", no_argument
, NULL
, OPTION_MNO_SYM32
},
1535 {"msoft-float", no_argument
, NULL
, OPTION_SOFT_FLOAT
},
1536 {"mhard-float", no_argument
, NULL
, OPTION_HARD_FLOAT
},
1537 {"msingle-float", no_argument
, NULL
, OPTION_SINGLE_FLOAT
},
1538 {"mdouble-float", no_argument
, NULL
, OPTION_DOUBLE_FLOAT
},
1540 /* Strictly speaking this next option is ELF specific,
1541 but we allow it for other ports as well in order to
1542 make testing easier. */
1543 {"32", no_argument
, NULL
, OPTION_32
},
1545 /* ELF-specific options. */
1546 {"KPIC", no_argument
, NULL
, OPTION_CALL_SHARED
},
1547 {"call_shared", no_argument
, NULL
, OPTION_CALL_SHARED
},
1548 {"call_nonpic", no_argument
, NULL
, OPTION_CALL_NONPIC
},
1549 {"non_shared", no_argument
, NULL
, OPTION_NON_SHARED
},
1550 {"xgot", no_argument
, NULL
, OPTION_XGOT
},
1551 {"mabi", required_argument
, NULL
, OPTION_MABI
},
1552 {"n32", no_argument
, NULL
, OPTION_N32
},
1553 {"64", no_argument
, NULL
, OPTION_64
},
1554 {"mdebug", no_argument
, NULL
, OPTION_MDEBUG
},
1555 {"no-mdebug", no_argument
, NULL
, OPTION_NO_MDEBUG
},
1556 {"mpdr", no_argument
, NULL
, OPTION_PDR
},
1557 {"mno-pdr", no_argument
, NULL
, OPTION_NO_PDR
},
1558 {"mvxworks-pic", no_argument
, NULL
, OPTION_MVXWORKS_PIC
},
1560 {NULL
, no_argument
, NULL
, 0}
1562 size_t md_longopts_size
= sizeof (md_longopts
);
1564 /* Information about either an Application Specific Extension or an
1565 optional architecture feature that, for simplicity, we treat in the
1566 same way as an ASE. */
1569 /* The name of the ASE, used in both the command-line and .set options. */
1572 /* The associated ASE_* flags. If the ASE is available on both 32-bit
1573 and 64-bit architectures, the flags here refer to the subset that
1574 is available on both. */
1577 /* The ASE_* flag used for instructions that are available on 64-bit
1578 architectures but that are not included in FLAGS. */
1579 unsigned int flags64
;
1581 /* The command-line options that turn the ASE on and off. */
1585 /* The minimum required architecture revisions for MIPS32, MIPS64,
1586 microMIPS32 and microMIPS64, or -1 if the extension isn't supported. */
1589 int micromips32_rev
;
1590 int micromips64_rev
;
1593 /* A table of all supported ASEs. */
1594 static const struct mips_ase mips_ases
[] = {
1595 { "dsp", ASE_DSP
, ASE_DSP64
,
1596 OPTION_DSP
, OPTION_NO_DSP
,
1599 { "dspr2", ASE_DSP
| ASE_DSPR2
, 0,
1600 OPTION_DSPR2
, OPTION_NO_DSPR2
,
1603 { "eva", ASE_EVA
, 0,
1604 OPTION_EVA
, OPTION_NO_EVA
,
1607 { "mcu", ASE_MCU
, 0,
1608 OPTION_MCU
, OPTION_NO_MCU
,
1611 /* Deprecated in MIPS64r5, but we don't implement that yet. */
1612 { "mdmx", ASE_MDMX
, 0,
1613 OPTION_MDMX
, OPTION_NO_MDMX
,
1616 /* Requires 64-bit FPRs, so the minimum MIPS32 revision is 2. */
1617 { "mips3d", ASE_MIPS3D
, 0,
1618 OPTION_MIPS3D
, OPTION_NO_MIPS3D
,
1622 OPTION_MT
, OPTION_NO_MT
,
1625 { "smartmips", ASE_SMARTMIPS
, 0,
1626 OPTION_SMARTMIPS
, OPTION_NO_SMARTMIPS
,
1629 { "virt", ASE_VIRT
, ASE_VIRT64
,
1630 OPTION_VIRT
, OPTION_NO_VIRT
,
1634 /* The set of ASEs that require -mfp64. */
1635 #define FP64_ASES (ASE_MIPS3D | ASE_MDMX)
1637 /* Groups of ASE_* flags that represent different revisions of an ASE. */
1638 static const unsigned int mips_ase_groups
[] = {
1644 The following pseudo-ops from the Kane and Heinrich MIPS book
1645 should be defined here, but are currently unsupported: .alias,
1646 .galive, .gjaldef, .gjrlive, .livereg, .noalias.
1648 The following pseudo-ops from the Kane and Heinrich MIPS book are
1649 specific to the type of debugging information being generated, and
1650 should be defined by the object format: .aent, .begin, .bend,
1651 .bgnb, .end, .endb, .ent, .fmask, .frame, .loc, .mask, .verstamp,
1654 The following pseudo-ops from the Kane and Heinrich MIPS book are
1655 not MIPS CPU specific, but are also not specific to the object file
1656 format. This file is probably the best place to define them, but
1657 they are not currently supported: .asm0, .endr, .lab, .struct. */
1659 static const pseudo_typeS mips_pseudo_table
[] =
1661 /* MIPS specific pseudo-ops. */
1662 {"option", s_option
, 0},
1663 {"set", s_mipsset
, 0},
1664 {"rdata", s_change_sec
, 'r'},
1665 {"sdata", s_change_sec
, 's'},
1666 {"livereg", s_ignore
, 0},
1667 {"abicalls", s_abicalls
, 0},
1668 {"cpload", s_cpload
, 0},
1669 {"cpsetup", s_cpsetup
, 0},
1670 {"cplocal", s_cplocal
, 0},
1671 {"cprestore", s_cprestore
, 0},
1672 {"cpreturn", s_cpreturn
, 0},
1673 {"dtprelword", s_dtprelword
, 0},
1674 {"dtpreldword", s_dtpreldword
, 0},
1675 {"tprelword", s_tprelword
, 0},
1676 {"tpreldword", s_tpreldword
, 0},
1677 {"gpvalue", s_gpvalue
, 0},
1678 {"gpword", s_gpword
, 0},
1679 {"gpdword", s_gpdword
, 0},
1680 {"ehword", s_ehword
, 0},
1681 {"cpadd", s_cpadd
, 0},
1682 {"insn", s_insn
, 0},
1684 /* Relatively generic pseudo-ops that happen to be used on MIPS
1686 {"asciiz", stringer
, 8 + 1},
1687 {"bss", s_change_sec
, 'b'},
1689 {"half", s_cons
, 1},
1690 {"dword", s_cons
, 3},
1691 {"weakext", s_mips_weakext
, 0},
1692 {"origin", s_org
, 0},
1693 {"repeat", s_rept
, 0},
1695 /* For MIPS this is non-standard, but we define it for consistency. */
1696 {"sbss", s_change_sec
, 'B'},
1698 /* These pseudo-ops are defined in read.c, but must be overridden
1699 here for one reason or another. */
1700 {"align", s_align
, 0},
1701 {"byte", s_cons
, 0},
1702 {"data", s_change_sec
, 'd'},
1703 {"double", s_float_cons
, 'd'},
1704 {"float", s_float_cons
, 'f'},
1705 {"globl", s_mips_globl
, 0},
1706 {"global", s_mips_globl
, 0},
1707 {"hword", s_cons
, 1},
1709 {"long", s_cons
, 2},
1710 {"octa", s_cons
, 4},
1711 {"quad", s_cons
, 3},
1712 {"section", s_change_section
, 0},
1713 {"short", s_cons
, 1},
1714 {"single", s_float_cons
, 'f'},
1715 {"stabd", s_mips_stab
, 'd'},
1716 {"stabn", s_mips_stab
, 'n'},
1717 {"stabs", s_mips_stab
, 's'},
1718 {"text", s_change_sec
, 't'},
1719 {"word", s_cons
, 2},
1721 { "extern", ecoff_directive_extern
, 0},
1726 static const pseudo_typeS mips_nonecoff_pseudo_table
[] =
1728 /* These pseudo-ops should be defined by the object file format.
1729 However, a.out doesn't support them, so we have versions here. */
1730 {"aent", s_mips_ent
, 1},
1731 {"bgnb", s_ignore
, 0},
1732 {"end", s_mips_end
, 0},
1733 {"endb", s_ignore
, 0},
1734 {"ent", s_mips_ent
, 0},
1735 {"file", s_mips_file
, 0},
1736 {"fmask", s_mips_mask
, 'F'},
1737 {"frame", s_mips_frame
, 0},
1738 {"loc", s_mips_loc
, 0},
1739 {"mask", s_mips_mask
, 'R'},
1740 {"verstamp", s_ignore
, 0},
1744 /* Export the ABI address size for use by TC_ADDRESS_BYTES for the
1745 purpose of the `.dc.a' internal pseudo-op. */
1748 mips_address_bytes (void)
1750 return HAVE_64BIT_ADDRESSES
? 8 : 4;
1753 extern void pop_insert (const pseudo_typeS
*);
1756 mips_pop_insert (void)
1758 pop_insert (mips_pseudo_table
);
1759 if (! ECOFF_DEBUGGING
)
1760 pop_insert (mips_nonecoff_pseudo_table
);
1763 /* Symbols labelling the current insn. */
1765 struct insn_label_list
1767 struct insn_label_list
*next
;
1771 static struct insn_label_list
*free_insn_labels
;
1772 #define label_list tc_segment_info_data.labels
1774 static void mips_clear_insn_labels (void);
1775 static void mips_mark_labels (void);
1776 static void mips_compressed_mark_labels (void);
1779 mips_clear_insn_labels (void)
1781 register struct insn_label_list
**pl
;
1782 segment_info_type
*si
;
1786 for (pl
= &free_insn_labels
; *pl
!= NULL
; pl
= &(*pl
)->next
)
1789 si
= seg_info (now_seg
);
1790 *pl
= si
->label_list
;
1791 si
->label_list
= NULL
;
1795 /* Mark instruction labels in MIPS16/microMIPS mode. */
1798 mips_mark_labels (void)
1800 if (HAVE_CODE_COMPRESSION
)
1801 mips_compressed_mark_labels ();
1804 static char *expr_end
;
1806 /* Expressions which appear in instructions. These are set by
1809 static expressionS imm_expr
;
1810 static expressionS imm2_expr
;
1811 static expressionS offset_expr
;
1813 /* Relocs associated with imm_expr and offset_expr. */
1815 static bfd_reloc_code_real_type imm_reloc
[3]
1816 = {BFD_RELOC_UNUSED
, BFD_RELOC_UNUSED
, BFD_RELOC_UNUSED
};
1817 static bfd_reloc_code_real_type offset_reloc
[3]
1818 = {BFD_RELOC_UNUSED
, BFD_RELOC_UNUSED
, BFD_RELOC_UNUSED
};
1820 /* This is set to the resulting size of the instruction to be produced
1821 by mips16_ip if an explicit extension is used or by mips_ip if an
1822 explicit size is supplied. */
1824 static unsigned int forced_insn_length
;
1826 /* True if we are assembling an instruction. All dot symbols defined during
1827 this time should be treated as code labels. */
1829 static bfd_boolean mips_assembling_insn
;
1831 /* The pdr segment for per procedure frame/regmask info. Not used for
1834 static segT pdr_seg
;
1836 /* The default target format to use. */
1838 #if defined (TE_FreeBSD)
1839 #define ELF_TARGET(PREFIX, ENDIAN) PREFIX "trad" ENDIAN "mips-freebsd"
1840 #elif defined (TE_TMIPS)
1841 #define ELF_TARGET(PREFIX, ENDIAN) PREFIX "trad" ENDIAN "mips"
1843 #define ELF_TARGET(PREFIX, ENDIAN) PREFIX ENDIAN "mips"
1847 mips_target_format (void)
1849 switch (OUTPUT_FLAVOR
)
1851 case bfd_target_elf_flavour
:
1853 if (!HAVE_64BIT_OBJECTS
&& !HAVE_NEWABI
)
1854 return (target_big_endian
1855 ? "elf32-bigmips-vxworks"
1856 : "elf32-littlemips-vxworks");
1858 return (target_big_endian
1859 ? (HAVE_64BIT_OBJECTS
1860 ? ELF_TARGET ("elf64-", "big")
1862 ? ELF_TARGET ("elf32-n", "big")
1863 : ELF_TARGET ("elf32-", "big")))
1864 : (HAVE_64BIT_OBJECTS
1865 ? ELF_TARGET ("elf64-", "little")
1867 ? ELF_TARGET ("elf32-n", "little")
1868 : ELF_TARGET ("elf32-", "little"))));
1875 /* Return the ISA revision that is currently in use, or 0 if we are
1876 generating code for MIPS V or below. */
1881 if (mips_opts
.isa
== ISA_MIPS32R2
|| mips_opts
.isa
== ISA_MIPS64R2
)
1884 /* microMIPS implies revision 2 or above. */
1885 if (mips_opts
.micromips
)
1888 if (mips_opts
.isa
== ISA_MIPS32
|| mips_opts
.isa
== ISA_MIPS64
)
1894 /* Return the mask of all ASEs that are revisions of those in FLAGS. */
1897 mips_ase_mask (unsigned int flags
)
1901 for (i
= 0; i
< ARRAY_SIZE (mips_ase_groups
); i
++)
1902 if (flags
& mips_ase_groups
[i
])
1903 flags
|= mips_ase_groups
[i
];
1907 /* Check whether the current ISA supports ASE. Issue a warning if
1911 mips_check_isa_supports_ase (const struct mips_ase
*ase
)
1915 static unsigned int warned_isa
;
1916 static unsigned int warned_fp32
;
1918 if (ISA_HAS_64BIT_REGS (mips_opts
.isa
))
1919 min_rev
= mips_opts
.micromips
? ase
->micromips64_rev
: ase
->mips64_rev
;
1921 min_rev
= mips_opts
.micromips
? ase
->micromips32_rev
: ase
->mips32_rev
;
1922 if ((min_rev
< 0 || mips_isa_rev () < min_rev
)
1923 && (warned_isa
& ase
->flags
) != ase
->flags
)
1925 warned_isa
|= ase
->flags
;
1926 base
= mips_opts
.micromips
? "microMIPS" : "MIPS";
1927 size
= ISA_HAS_64BIT_REGS (mips_opts
.isa
) ? 64 : 32;
1929 as_warn (_("The %d-bit %s architecture does not support the"
1930 " `%s' extension"), size
, base
, ase
->name
);
1932 as_warn (_("The `%s' extension requires %s%d revision %d or greater"),
1933 ase
->name
, base
, size
, min_rev
);
1935 if ((ase
->flags
& FP64_ASES
)
1937 && (warned_fp32
& ase
->flags
) != ase
->flags
)
1939 warned_fp32
|= ase
->flags
;
1940 as_warn (_("The `%s' extension requires 64-bit FPRs"), ase
->name
);
1944 /* Check all enabled ASEs to see whether they are supported by the
1945 chosen architecture. */
1948 mips_check_isa_supports_ases (void)
1950 unsigned int i
, mask
;
1952 for (i
= 0; i
< ARRAY_SIZE (mips_ases
); i
++)
1954 mask
= mips_ase_mask (mips_ases
[i
].flags
);
1955 if ((mips_opts
.ase
& mask
) == mips_ases
[i
].flags
)
1956 mips_check_isa_supports_ase (&mips_ases
[i
]);
1960 /* Set the state of ASE to ENABLED_P. Return the mask of ASE_* flags
1961 that were affected. */
1964 mips_set_ase (const struct mips_ase
*ase
, bfd_boolean enabled_p
)
1968 mask
= mips_ase_mask (ase
->flags
);
1969 mips_opts
.ase
&= ~mask
;
1971 mips_opts
.ase
|= ase
->flags
;
1975 /* Return the ASE called NAME, or null if none. */
1977 static const struct mips_ase
*
1978 mips_lookup_ase (const char *name
)
1982 for (i
= 0; i
< ARRAY_SIZE (mips_ases
); i
++)
1983 if (strcmp (name
, mips_ases
[i
].name
) == 0)
1984 return &mips_ases
[i
];
1988 /* Return the length of a microMIPS instruction in bytes. If bits of
1989 the mask beyond the low 16 are 0, then it is a 16-bit instruction.
1990 Otherwise assume a 32-bit instruction; 48-bit instructions (0x1f
1991 major opcode) will require further modifications to the opcode
1994 static inline unsigned int
1995 micromips_insn_length (const struct mips_opcode
*mo
)
1997 return (mo
->mask
>> 16) == 0 ? 2 : 4;
2000 /* Return the length of MIPS16 instruction OPCODE. */
2002 static inline unsigned int
2003 mips16_opcode_length (unsigned long opcode
)
2005 return (opcode
>> 16) == 0 ? 2 : 4;
2008 /* Return the length of instruction INSN. */
2010 static inline unsigned int
2011 insn_length (const struct mips_cl_insn
*insn
)
2013 if (mips_opts
.micromips
)
2014 return micromips_insn_length (insn
->insn_mo
);
2015 else if (mips_opts
.mips16
)
2016 return mips16_opcode_length (insn
->insn_opcode
);
2021 /* Initialise INSN from opcode entry MO. Leave its position unspecified. */
2024 create_insn (struct mips_cl_insn
*insn
, const struct mips_opcode
*mo
)
2029 insn
->insn_opcode
= mo
->match
;
2032 for (i
= 0; i
< ARRAY_SIZE (insn
->fixp
); i
++)
2033 insn
->fixp
[i
] = NULL
;
2034 insn
->fixed_p
= (mips_opts
.noreorder
> 0);
2035 insn
->noreorder_p
= (mips_opts
.noreorder
> 0);
2036 insn
->mips16_absolute_jump_p
= 0;
2037 insn
->complete_p
= 0;
2038 insn
->cleared_p
= 0;
2041 /* Record the current MIPS16/microMIPS mode in now_seg. */
2044 mips_record_compressed_mode (void)
2046 segment_info_type
*si
;
2048 si
= seg_info (now_seg
);
2049 if (si
->tc_segment_info_data
.mips16
!= mips_opts
.mips16
)
2050 si
->tc_segment_info_data
.mips16
= mips_opts
.mips16
;
2051 if (si
->tc_segment_info_data
.micromips
!= mips_opts
.micromips
)
2052 si
->tc_segment_info_data
.micromips
= mips_opts
.micromips
;
2055 /* Read a standard MIPS instruction from BUF. */
2057 static unsigned long
2058 read_insn (char *buf
)
2060 if (target_big_endian
)
2061 return bfd_getb32 ((bfd_byte
*) buf
);
2063 return bfd_getl32 ((bfd_byte
*) buf
);
2066 /* Write standard MIPS instruction INSN to BUF. Return a pointer to
2070 write_insn (char *buf
, unsigned int insn
)
2072 md_number_to_chars (buf
, insn
, 4);
2076 /* Read a microMIPS or MIPS16 opcode from BUF, given that it
2077 has length LENGTH. */
2079 static unsigned long
2080 read_compressed_insn (char *buf
, unsigned int length
)
2086 for (i
= 0; i
< length
; i
+= 2)
2089 if (target_big_endian
)
2090 insn
|= bfd_getb16 ((char *) buf
);
2092 insn
|= bfd_getl16 ((char *) buf
);
2098 /* Write microMIPS or MIPS16 instruction INSN to BUF, given that the
2099 instruction is LENGTH bytes long. Return a pointer to the next byte. */
2102 write_compressed_insn (char *buf
, unsigned int insn
, unsigned int length
)
2106 for (i
= 0; i
< length
; i
+= 2)
2107 md_number_to_chars (buf
+ i
, insn
>> ((length
- i
- 2) * 8), 2);
2108 return buf
+ length
;
2111 /* Install INSN at the location specified by its "frag" and "where" fields. */
2114 install_insn (const struct mips_cl_insn
*insn
)
2116 char *f
= insn
->frag
->fr_literal
+ insn
->where
;
2117 if (HAVE_CODE_COMPRESSION
)
2118 write_compressed_insn (f
, insn
->insn_opcode
, insn_length (insn
));
2120 write_insn (f
, insn
->insn_opcode
);
2121 mips_record_compressed_mode ();
2124 /* Move INSN to offset WHERE in FRAG. Adjust the fixups accordingly
2125 and install the opcode in the new location. */
2128 move_insn (struct mips_cl_insn
*insn
, fragS
*frag
, long where
)
2133 insn
->where
= where
;
2134 for (i
= 0; i
< ARRAY_SIZE (insn
->fixp
); i
++)
2135 if (insn
->fixp
[i
] != NULL
)
2137 insn
->fixp
[i
]->fx_frag
= frag
;
2138 insn
->fixp
[i
]->fx_where
= where
;
2140 install_insn (insn
);
2143 /* Add INSN to the end of the output. */
2146 add_fixed_insn (struct mips_cl_insn
*insn
)
2148 char *f
= frag_more (insn_length (insn
));
2149 move_insn (insn
, frag_now
, f
- frag_now
->fr_literal
);
2152 /* Start a variant frag and move INSN to the start of the variant part,
2153 marking it as fixed. The other arguments are as for frag_var. */
2156 add_relaxed_insn (struct mips_cl_insn
*insn
, int max_chars
, int var
,
2157 relax_substateT subtype
, symbolS
*symbol
, offsetT offset
)
2159 frag_grow (max_chars
);
2160 move_insn (insn
, frag_now
, frag_more (0) - frag_now
->fr_literal
);
2162 frag_var (rs_machine_dependent
, max_chars
, var
,
2163 subtype
, symbol
, offset
, NULL
);
2166 /* Insert N copies of INSN into the history buffer, starting at
2167 position FIRST. Neither FIRST nor N need to be clipped. */
2170 insert_into_history (unsigned int first
, unsigned int n
,
2171 const struct mips_cl_insn
*insn
)
2173 if (mips_relax
.sequence
!= 2)
2177 for (i
= ARRAY_SIZE (history
); i
-- > first
;)
2179 history
[i
] = history
[i
- n
];
2185 /* Initialize vr4120_conflicts. There is a bit of duplication here:
2186 the idea is to make it obvious at a glance that each errata is
2190 init_vr4120_conflicts (void)
2192 #define CONFLICT(FIRST, SECOND) \
2193 vr4120_conflicts[FIX_VR4120_##FIRST] |= 1 << FIX_VR4120_##SECOND
2195 /* Errata 21 - [D]DIV[U] after [D]MACC */
2196 CONFLICT (MACC
, DIV
);
2197 CONFLICT (DMACC
, DIV
);
2199 /* Errata 23 - Continuous DMULT[U]/DMACC instructions. */
2200 CONFLICT (DMULT
, DMULT
);
2201 CONFLICT (DMULT
, DMACC
);
2202 CONFLICT (DMACC
, DMULT
);
2203 CONFLICT (DMACC
, DMACC
);
2205 /* Errata 24 - MT{LO,HI} after [D]MACC */
2206 CONFLICT (MACC
, MTHILO
);
2207 CONFLICT (DMACC
, MTHILO
);
2209 /* VR4181A errata MD(1): "If a MULT, MULTU, DMULT or DMULTU
2210 instruction is executed immediately after a MACC or DMACC
2211 instruction, the result of [either instruction] is incorrect." */
2212 CONFLICT (MACC
, MULT
);
2213 CONFLICT (MACC
, DMULT
);
2214 CONFLICT (DMACC
, MULT
);
2215 CONFLICT (DMACC
, DMULT
);
2217 /* VR4181A errata MD(4): "If a MACC or DMACC instruction is
2218 executed immediately after a DMULT, DMULTU, DIV, DIVU,
2219 DDIV or DDIVU instruction, the result of the MACC or
2220 DMACC instruction is incorrect.". */
2221 CONFLICT (DMULT
, MACC
);
2222 CONFLICT (DMULT
, DMACC
);
2223 CONFLICT (DIV
, MACC
);
2224 CONFLICT (DIV
, DMACC
);
2234 #define RTYPE_MASK 0x1ff00
2235 #define RTYPE_NUM 0x00100
2236 #define RTYPE_FPU 0x00200
2237 #define RTYPE_FCC 0x00400
2238 #define RTYPE_VEC 0x00800
2239 #define RTYPE_GP 0x01000
2240 #define RTYPE_CP0 0x02000
2241 #define RTYPE_PC 0x04000
2242 #define RTYPE_ACC 0x08000
2243 #define RTYPE_CCC 0x10000
2244 #define RNUM_MASK 0x000ff
2245 #define RWARN 0x80000
2247 #define GENERIC_REGISTER_NUMBERS \
2248 {"$0", RTYPE_NUM | 0}, \
2249 {"$1", RTYPE_NUM | 1}, \
2250 {"$2", RTYPE_NUM | 2}, \
2251 {"$3", RTYPE_NUM | 3}, \
2252 {"$4", RTYPE_NUM | 4}, \
2253 {"$5", RTYPE_NUM | 5}, \
2254 {"$6", RTYPE_NUM | 6}, \
2255 {"$7", RTYPE_NUM | 7}, \
2256 {"$8", RTYPE_NUM | 8}, \
2257 {"$9", RTYPE_NUM | 9}, \
2258 {"$10", RTYPE_NUM | 10}, \
2259 {"$11", RTYPE_NUM | 11}, \
2260 {"$12", RTYPE_NUM | 12}, \
2261 {"$13", RTYPE_NUM | 13}, \
2262 {"$14", RTYPE_NUM | 14}, \
2263 {"$15", RTYPE_NUM | 15}, \
2264 {"$16", RTYPE_NUM | 16}, \
2265 {"$17", RTYPE_NUM | 17}, \
2266 {"$18", RTYPE_NUM | 18}, \
2267 {"$19", RTYPE_NUM | 19}, \
2268 {"$20", RTYPE_NUM | 20}, \
2269 {"$21", RTYPE_NUM | 21}, \
2270 {"$22", RTYPE_NUM | 22}, \
2271 {"$23", RTYPE_NUM | 23}, \
2272 {"$24", RTYPE_NUM | 24}, \
2273 {"$25", RTYPE_NUM | 25}, \
2274 {"$26", RTYPE_NUM | 26}, \
2275 {"$27", RTYPE_NUM | 27}, \
2276 {"$28", RTYPE_NUM | 28}, \
2277 {"$29", RTYPE_NUM | 29}, \
2278 {"$30", RTYPE_NUM | 30}, \
2279 {"$31", RTYPE_NUM | 31}
2281 #define FPU_REGISTER_NAMES \
2282 {"$f0", RTYPE_FPU | 0}, \
2283 {"$f1", RTYPE_FPU | 1}, \
2284 {"$f2", RTYPE_FPU | 2}, \
2285 {"$f3", RTYPE_FPU | 3}, \
2286 {"$f4", RTYPE_FPU | 4}, \
2287 {"$f5", RTYPE_FPU | 5}, \
2288 {"$f6", RTYPE_FPU | 6}, \
2289 {"$f7", RTYPE_FPU | 7}, \
2290 {"$f8", RTYPE_FPU | 8}, \
2291 {"$f9", RTYPE_FPU | 9}, \
2292 {"$f10", RTYPE_FPU | 10}, \
2293 {"$f11", RTYPE_FPU | 11}, \
2294 {"$f12", RTYPE_FPU | 12}, \
2295 {"$f13", RTYPE_FPU | 13}, \
2296 {"$f14", RTYPE_FPU | 14}, \
2297 {"$f15", RTYPE_FPU | 15}, \
2298 {"$f16", RTYPE_FPU | 16}, \
2299 {"$f17", RTYPE_FPU | 17}, \
2300 {"$f18", RTYPE_FPU | 18}, \
2301 {"$f19", RTYPE_FPU | 19}, \
2302 {"$f20", RTYPE_FPU | 20}, \
2303 {"$f21", RTYPE_FPU | 21}, \
2304 {"$f22", RTYPE_FPU | 22}, \
2305 {"$f23", RTYPE_FPU | 23}, \
2306 {"$f24", RTYPE_FPU | 24}, \
2307 {"$f25", RTYPE_FPU | 25}, \
2308 {"$f26", RTYPE_FPU | 26}, \
2309 {"$f27", RTYPE_FPU | 27}, \
2310 {"$f28", RTYPE_FPU | 28}, \
2311 {"$f29", RTYPE_FPU | 29}, \
2312 {"$f30", RTYPE_FPU | 30}, \
2313 {"$f31", RTYPE_FPU | 31}
2315 #define FPU_CONDITION_CODE_NAMES \
2316 {"$fcc0", RTYPE_FCC | 0}, \
2317 {"$fcc1", RTYPE_FCC | 1}, \
2318 {"$fcc2", RTYPE_FCC | 2}, \
2319 {"$fcc3", RTYPE_FCC | 3}, \
2320 {"$fcc4", RTYPE_FCC | 4}, \
2321 {"$fcc5", RTYPE_FCC | 5}, \
2322 {"$fcc6", RTYPE_FCC | 6}, \
2323 {"$fcc7", RTYPE_FCC | 7}
2325 #define COPROC_CONDITION_CODE_NAMES \
2326 {"$cc0", RTYPE_FCC | RTYPE_CCC | 0}, \
2327 {"$cc1", RTYPE_FCC | RTYPE_CCC | 1}, \
2328 {"$cc2", RTYPE_FCC | RTYPE_CCC | 2}, \
2329 {"$cc3", RTYPE_FCC | RTYPE_CCC | 3}, \
2330 {"$cc4", RTYPE_FCC | RTYPE_CCC | 4}, \
2331 {"$cc5", RTYPE_FCC | RTYPE_CCC | 5}, \
2332 {"$cc6", RTYPE_FCC | RTYPE_CCC | 6}, \
2333 {"$cc7", RTYPE_FCC | RTYPE_CCC | 7}
2335 #define N32N64_SYMBOLIC_REGISTER_NAMES \
2336 {"$a4", RTYPE_GP | 8}, \
2337 {"$a5", RTYPE_GP | 9}, \
2338 {"$a6", RTYPE_GP | 10}, \
2339 {"$a7", RTYPE_GP | 11}, \
2340 {"$ta0", RTYPE_GP | 8}, /* alias for $a4 */ \
2341 {"$ta1", RTYPE_GP | 9}, /* alias for $a5 */ \
2342 {"$ta2", RTYPE_GP | 10}, /* alias for $a6 */ \
2343 {"$ta3", RTYPE_GP | 11}, /* alias for $a7 */ \
2344 {"$t0", RTYPE_GP | 12}, \
2345 {"$t1", RTYPE_GP | 13}, \
2346 {"$t2", RTYPE_GP | 14}, \
2347 {"$t3", RTYPE_GP | 15}
2349 #define O32_SYMBOLIC_REGISTER_NAMES \
2350 {"$t0", RTYPE_GP | 8}, \
2351 {"$t1", RTYPE_GP | 9}, \
2352 {"$t2", RTYPE_GP | 10}, \
2353 {"$t3", RTYPE_GP | 11}, \
2354 {"$t4", RTYPE_GP | 12}, \
2355 {"$t5", RTYPE_GP | 13}, \
2356 {"$t6", RTYPE_GP | 14}, \
2357 {"$t7", RTYPE_GP | 15}, \
2358 {"$ta0", RTYPE_GP | 12}, /* alias for $t4 */ \
2359 {"$ta1", RTYPE_GP | 13}, /* alias for $t5 */ \
2360 {"$ta2", RTYPE_GP | 14}, /* alias for $t6 */ \
2361 {"$ta3", RTYPE_GP | 15} /* alias for $t7 */
2363 /* Remaining symbolic register names */
2364 #define SYMBOLIC_REGISTER_NAMES \
2365 {"$zero", RTYPE_GP | 0}, \
2366 {"$at", RTYPE_GP | 1}, \
2367 {"$AT", RTYPE_GP | 1}, \
2368 {"$v0", RTYPE_GP | 2}, \
2369 {"$v1", RTYPE_GP | 3}, \
2370 {"$a0", RTYPE_GP | 4}, \
2371 {"$a1", RTYPE_GP | 5}, \
2372 {"$a2", RTYPE_GP | 6}, \
2373 {"$a3", RTYPE_GP | 7}, \
2374 {"$s0", RTYPE_GP | 16}, \
2375 {"$s1", RTYPE_GP | 17}, \
2376 {"$s2", RTYPE_GP | 18}, \
2377 {"$s3", RTYPE_GP | 19}, \
2378 {"$s4", RTYPE_GP | 20}, \
2379 {"$s5", RTYPE_GP | 21}, \
2380 {"$s6", RTYPE_GP | 22}, \
2381 {"$s7", RTYPE_GP | 23}, \
2382 {"$t8", RTYPE_GP | 24}, \
2383 {"$t9", RTYPE_GP | 25}, \
2384 {"$k0", RTYPE_GP | 26}, \
2385 {"$kt0", RTYPE_GP | 26}, \
2386 {"$k1", RTYPE_GP | 27}, \
2387 {"$kt1", RTYPE_GP | 27}, \
2388 {"$gp", RTYPE_GP | 28}, \
2389 {"$sp", RTYPE_GP | 29}, \
2390 {"$s8", RTYPE_GP | 30}, \
2391 {"$fp", RTYPE_GP | 30}, \
2392 {"$ra", RTYPE_GP | 31}
2394 #define MIPS16_SPECIAL_REGISTER_NAMES \
2395 {"$pc", RTYPE_PC | 0}
2397 #define MDMX_VECTOR_REGISTER_NAMES \
2398 /* {"$v0", RTYPE_VEC | 0}, clash with REG 2 above */ \
2399 /* {"$v1", RTYPE_VEC | 1}, clash with REG 3 above */ \
2400 {"$v2", RTYPE_VEC | 2}, \
2401 {"$v3", RTYPE_VEC | 3}, \
2402 {"$v4", RTYPE_VEC | 4}, \
2403 {"$v5", RTYPE_VEC | 5}, \
2404 {"$v6", RTYPE_VEC | 6}, \
2405 {"$v7", RTYPE_VEC | 7}, \
2406 {"$v8", RTYPE_VEC | 8}, \
2407 {"$v9", RTYPE_VEC | 9}, \
2408 {"$v10", RTYPE_VEC | 10}, \
2409 {"$v11", RTYPE_VEC | 11}, \
2410 {"$v12", RTYPE_VEC | 12}, \
2411 {"$v13", RTYPE_VEC | 13}, \
2412 {"$v14", RTYPE_VEC | 14}, \
2413 {"$v15", RTYPE_VEC | 15}, \
2414 {"$v16", RTYPE_VEC | 16}, \
2415 {"$v17", RTYPE_VEC | 17}, \
2416 {"$v18", RTYPE_VEC | 18}, \
2417 {"$v19", RTYPE_VEC | 19}, \
2418 {"$v20", RTYPE_VEC | 20}, \
2419 {"$v21", RTYPE_VEC | 21}, \
2420 {"$v22", RTYPE_VEC | 22}, \
2421 {"$v23", RTYPE_VEC | 23}, \
2422 {"$v24", RTYPE_VEC | 24}, \
2423 {"$v25", RTYPE_VEC | 25}, \
2424 {"$v26", RTYPE_VEC | 26}, \
2425 {"$v27", RTYPE_VEC | 27}, \
2426 {"$v28", RTYPE_VEC | 28}, \
2427 {"$v29", RTYPE_VEC | 29}, \
2428 {"$v30", RTYPE_VEC | 30}, \
2429 {"$v31", RTYPE_VEC | 31}
2431 #define MIPS_DSP_ACCUMULATOR_NAMES \
2432 {"$ac0", RTYPE_ACC | 0}, \
2433 {"$ac1", RTYPE_ACC | 1}, \
2434 {"$ac2", RTYPE_ACC | 2}, \
2435 {"$ac3", RTYPE_ACC | 3}
2437 static const struct regname reg_names
[] = {
2438 GENERIC_REGISTER_NUMBERS
,
2440 FPU_CONDITION_CODE_NAMES
,
2441 COPROC_CONDITION_CODE_NAMES
,
2443 /* The $txx registers depends on the abi,
2444 these will be added later into the symbol table from
2445 one of the tables below once mips_abi is set after
2446 parsing of arguments from the command line. */
2447 SYMBOLIC_REGISTER_NAMES
,
2449 MIPS16_SPECIAL_REGISTER_NAMES
,
2450 MDMX_VECTOR_REGISTER_NAMES
,
2451 MIPS_DSP_ACCUMULATOR_NAMES
,
2455 static const struct regname reg_names_o32
[] = {
2456 O32_SYMBOLIC_REGISTER_NAMES
,
2460 static const struct regname reg_names_n32n64
[] = {
2461 N32N64_SYMBOLIC_REGISTER_NAMES
,
2465 /* Check if S points at a valid register specifier according to TYPES.
2466 If so, then return 1, advance S to consume the specifier and store
2467 the register's number in REGNOP, otherwise return 0. */
2470 reg_lookup (char **s
, unsigned int types
, unsigned int *regnop
)
2477 /* Find end of name. */
2479 if (is_name_beginner (*e
))
2481 while (is_part_of_name (*e
))
2484 /* Terminate name. */
2488 /* Look for a register symbol. */
2489 if ((symbolP
= symbol_find (*s
)) && S_GET_SEGMENT (symbolP
) == reg_section
)
2491 int r
= S_GET_VALUE (symbolP
);
2493 reg
= r
& RNUM_MASK
;
2494 else if ((types
& RTYPE_VEC
) && (r
& ~1) == (RTYPE_GP
| 2))
2495 /* Convert GP reg $v0/1 to MDMX reg $v0/1! */
2496 reg
= (r
& RNUM_MASK
) - 2;
2498 /* Else see if this is a register defined in an itbl entry. */
2499 else if ((types
& RTYPE_GP
) && itbl_have_entries
)
2506 if (itbl_get_reg_val (n
, &r
))
2507 reg
= r
& RNUM_MASK
;
2510 /* Advance to next token if a register was recognised. */
2513 else if (types
& RWARN
)
2514 as_warn (_("Unrecognized register name `%s'"), *s
);
2522 /* Check if S points at a valid register list according to TYPES.
2523 If so, then return 1, advance S to consume the list and store
2524 the registers present on the list as a bitmask of ones in REGLISTP,
2525 otherwise return 0. A valid list comprises a comma-separated
2526 enumeration of valid single registers and/or dash-separated
2527 contiguous register ranges as determined by their numbers.
2529 As a special exception if one of s0-s7 registers is specified as
2530 the range's lower delimiter and s8 (fp) is its upper one, then no
2531 registers whose numbers place them between s7 and s8 (i.e. $24-$29)
2532 are selected; they have to be listed separately if needed. */
2535 reglist_lookup (char **s
, unsigned int types
, unsigned int *reglistp
)
2537 unsigned int reglist
= 0;
2538 unsigned int lastregno
;
2539 bfd_boolean ok
= TRUE
;
2540 unsigned int regmask
;
2541 char *s_endlist
= *s
;
2545 while (reg_lookup (s
, types
, ®no
))
2551 ok
= reg_lookup (s
, types
, &lastregno
);
2552 if (ok
&& lastregno
< regno
)
2558 if (lastregno
== FP
&& regno
>= S0
&& regno
<= S7
)
2563 regmask
= 1 << lastregno
;
2564 regmask
= (regmask
<< 1) - 1;
2565 regmask
^= (1 << regno
) - 1;
2579 *reglistp
= reglist
;
2580 return ok
&& reglist
!= 0;
2584 mips_lookup_reg_pair (unsigned int regno1
, unsigned int regno2
,
2585 const unsigned int *map1
, const unsigned int *map2
,
2590 for (i
= 0; i
< count
; i
++)
2591 if (map1
[i
] == regno1
&& map2
[i
] == regno2
)
2596 /* Return TRUE if opcode MO is valid on the currently selected ISA, ASE
2597 and architecture. Use is_opcode_valid_16 for MIPS16 opcodes. */
2600 is_opcode_valid (const struct mips_opcode
*mo
)
2602 int isa
= mips_opts
.isa
;
2603 int ase
= mips_opts
.ase
;
2607 if (ISA_HAS_64BIT_REGS (mips_opts
.isa
))
2608 for (i
= 0; i
< ARRAY_SIZE (mips_ases
); i
++)
2609 if ((ase
& mips_ases
[i
].flags
) == mips_ases
[i
].flags
)
2610 ase
|= mips_ases
[i
].flags64
;
2612 if (!opcode_is_member (mo
, isa
, ase
, mips_opts
.arch
))
2615 /* Check whether the instruction or macro requires single-precision or
2616 double-precision floating-point support. Note that this information is
2617 stored differently in the opcode table for insns and macros. */
2618 if (mo
->pinfo
== INSN_MACRO
)
2620 fp_s
= mo
->pinfo2
& INSN2_M_FP_S
;
2621 fp_d
= mo
->pinfo2
& INSN2_M_FP_D
;
2625 fp_s
= mo
->pinfo
& FP_S
;
2626 fp_d
= mo
->pinfo
& FP_D
;
2629 if (fp_d
&& (mips_opts
.soft_float
|| mips_opts
.single_float
))
2632 if (fp_s
&& mips_opts
.soft_float
)
2638 /* Return TRUE if the MIPS16 opcode MO is valid on the currently
2639 selected ISA and architecture. */
2642 is_opcode_valid_16 (const struct mips_opcode
*mo
)
2644 return opcode_is_member (mo
, mips_opts
.isa
, 0, mips_opts
.arch
);
2647 /* Return TRUE if the size of the microMIPS opcode MO matches one
2648 explicitly requested. Always TRUE in the standard MIPS mode. */
2651 is_size_valid (const struct mips_opcode
*mo
)
2653 if (!mips_opts
.micromips
)
2656 if (mips_opts
.insn32
)
2658 if (mo
->pinfo
!= INSN_MACRO
&& micromips_insn_length (mo
) != 4)
2660 if ((mo
->pinfo2
& INSN2_BRANCH_DELAY_16BIT
) != 0)
2663 if (!forced_insn_length
)
2665 if (mo
->pinfo
== INSN_MACRO
)
2667 return forced_insn_length
== micromips_insn_length (mo
);
2670 /* Return TRUE if the microMIPS opcode MO is valid for the delay slot
2671 of the preceding instruction. Always TRUE in the standard MIPS mode.
2673 We don't accept macros in 16-bit delay slots to avoid a case where
2674 a macro expansion fails because it relies on a preceding 32-bit real
2675 instruction to have matched and does not handle the operands correctly.
2676 The only macros that may expand to 16-bit instructions are JAL that
2677 cannot be placed in a delay slot anyway, and corner cases of BALIGN
2678 and BGT (that likewise cannot be placed in a delay slot) that decay to
2679 a NOP. In all these cases the macros precede any corresponding real
2680 instruction definitions in the opcode table, so they will match in the
2681 second pass where the size of the delay slot is ignored and therefore
2682 produce correct code. */
2685 is_delay_slot_valid (const struct mips_opcode
*mo
)
2687 if (!mips_opts
.micromips
)
2690 if (mo
->pinfo
== INSN_MACRO
)
2691 return (history
[0].insn_mo
->pinfo2
& INSN2_BRANCH_DELAY_16BIT
) == 0;
2692 if ((history
[0].insn_mo
->pinfo2
& INSN2_BRANCH_DELAY_32BIT
) != 0
2693 && micromips_insn_length (mo
) != 4)
2695 if ((history
[0].insn_mo
->pinfo2
& INSN2_BRANCH_DELAY_16BIT
) != 0
2696 && micromips_insn_length (mo
) != 2)
2702 /* This function is called once, at assembler startup time. It should set up
2703 all the tables, etc. that the MD part of the assembler will need. */
2708 const char *retval
= NULL
;
2712 if (mips_pic
!= NO_PIC
)
2714 if (g_switch_seen
&& g_switch_value
!= 0)
2715 as_bad (_("-G may not be used in position-independent code"));
2719 if (! bfd_set_arch_mach (stdoutput
, bfd_arch_mips
, file_mips_arch
))
2720 as_warn (_("Could not set architecture and machine"));
2722 op_hash
= hash_new ();
2724 for (i
= 0; i
< NUMOPCODES
;)
2726 const char *name
= mips_opcodes
[i
].name
;
2728 retval
= hash_insert (op_hash
, name
, (void *) &mips_opcodes
[i
]);
2731 fprintf (stderr
, _("internal error: can't hash `%s': %s\n"),
2732 mips_opcodes
[i
].name
, retval
);
2733 /* Probably a memory allocation problem? Give up now. */
2734 as_fatal (_("Broken assembler. No assembly attempted."));
2738 if (mips_opcodes
[i
].pinfo
!= INSN_MACRO
)
2740 if (!validate_mips_insn (&mips_opcodes
[i
]))
2742 if (nop_insn
.insn_mo
== NULL
&& strcmp (name
, "nop") == 0)
2744 create_insn (&nop_insn
, mips_opcodes
+ i
);
2745 if (mips_fix_loongson2f_nop
)
2746 nop_insn
.insn_opcode
= LOONGSON2F_NOP_INSN
;
2747 nop_insn
.fixed_p
= 1;
2752 while ((i
< NUMOPCODES
) && !strcmp (mips_opcodes
[i
].name
, name
));
2755 mips16_op_hash
= hash_new ();
2758 while (i
< bfd_mips16_num_opcodes
)
2760 const char *name
= mips16_opcodes
[i
].name
;
2762 retval
= hash_insert (mips16_op_hash
, name
, (void *) &mips16_opcodes
[i
]);
2764 as_fatal (_("internal: can't hash `%s': %s"),
2765 mips16_opcodes
[i
].name
, retval
);
2768 if (mips16_opcodes
[i
].pinfo
!= INSN_MACRO
2769 && ((mips16_opcodes
[i
].match
& mips16_opcodes
[i
].mask
)
2770 != mips16_opcodes
[i
].match
))
2772 fprintf (stderr
, _("internal error: bad mips16 opcode: %s %s\n"),
2773 mips16_opcodes
[i
].name
, mips16_opcodes
[i
].args
);
2776 if (mips16_nop_insn
.insn_mo
== NULL
&& strcmp (name
, "nop") == 0)
2778 create_insn (&mips16_nop_insn
, mips16_opcodes
+ i
);
2779 mips16_nop_insn
.fixed_p
= 1;
2783 while (i
< bfd_mips16_num_opcodes
2784 && strcmp (mips16_opcodes
[i
].name
, name
) == 0);
2787 micromips_op_hash
= hash_new ();
2790 while (i
< bfd_micromips_num_opcodes
)
2792 const char *name
= micromips_opcodes
[i
].name
;
2794 retval
= hash_insert (micromips_op_hash
, name
,
2795 (void *) µmips_opcodes
[i
]);
2797 as_fatal (_("internal: can't hash `%s': %s"),
2798 micromips_opcodes
[i
].name
, retval
);
2800 if (micromips_opcodes
[i
].pinfo
!= INSN_MACRO
)
2802 struct mips_cl_insn
*micromips_nop_insn
;
2804 if (!validate_micromips_insn (µmips_opcodes
[i
]))
2807 if (micromips_insn_length (micromips_opcodes
+ i
) == 2)
2808 micromips_nop_insn
= µmips_nop16_insn
;
2809 else if (micromips_insn_length (micromips_opcodes
+ i
) == 4)
2810 micromips_nop_insn
= µmips_nop32_insn
;
2814 if (micromips_nop_insn
->insn_mo
== NULL
2815 && strcmp (name
, "nop") == 0)
2817 create_insn (micromips_nop_insn
, micromips_opcodes
+ i
);
2818 micromips_nop_insn
->fixed_p
= 1;
2821 while (++i
< bfd_micromips_num_opcodes
2822 && strcmp (micromips_opcodes
[i
].name
, name
) == 0);
2826 as_fatal (_("Broken assembler. No assembly attempted."));
2828 /* We add all the general register names to the symbol table. This
2829 helps us detect invalid uses of them. */
2830 for (i
= 0; reg_names
[i
].name
; i
++)
2831 symbol_table_insert (symbol_new (reg_names
[i
].name
, reg_section
,
2832 reg_names
[i
].num
, /* & RNUM_MASK, */
2833 &zero_address_frag
));
2835 for (i
= 0; reg_names_n32n64
[i
].name
; i
++)
2836 symbol_table_insert (symbol_new (reg_names_n32n64
[i
].name
, reg_section
,
2837 reg_names_n32n64
[i
].num
, /* & RNUM_MASK, */
2838 &zero_address_frag
));
2840 for (i
= 0; reg_names_o32
[i
].name
; i
++)
2841 symbol_table_insert (symbol_new (reg_names_o32
[i
].name
, reg_section
,
2842 reg_names_o32
[i
].num
, /* & RNUM_MASK, */
2843 &zero_address_frag
));
2845 mips_no_prev_insn ();
2848 mips_cprmask
[0] = 0;
2849 mips_cprmask
[1] = 0;
2850 mips_cprmask
[2] = 0;
2851 mips_cprmask
[3] = 0;
2853 /* set the default alignment for the text section (2**2) */
2854 record_alignment (text_section
, 2);
2856 bfd_set_gp_size (stdoutput
, g_switch_value
);
2858 /* On a native system other than VxWorks, sections must be aligned
2859 to 16 byte boundaries. When configured for an embedded ELF
2860 target, we don't bother. */
2861 if (strncmp (TARGET_OS
, "elf", 3) != 0
2862 && strncmp (TARGET_OS
, "vxworks", 7) != 0)
2864 (void) bfd_set_section_alignment (stdoutput
, text_section
, 4);
2865 (void) bfd_set_section_alignment (stdoutput
, data_section
, 4);
2866 (void) bfd_set_section_alignment (stdoutput
, bss_section
, 4);
2869 /* Create a .reginfo section for register masks and a .mdebug
2870 section for debugging information. */
2878 subseg
= now_subseg
;
2880 /* The ABI says this section should be loaded so that the
2881 running program can access it. However, we don't load it
2882 if we are configured for an embedded target */
2883 flags
= SEC_READONLY
| SEC_DATA
;
2884 if (strncmp (TARGET_OS
, "elf", 3) != 0)
2885 flags
|= SEC_ALLOC
| SEC_LOAD
;
2887 if (mips_abi
!= N64_ABI
)
2889 sec
= subseg_new (".reginfo", (subsegT
) 0);
2891 bfd_set_section_flags (stdoutput
, sec
, flags
);
2892 bfd_set_section_alignment (stdoutput
, sec
, HAVE_NEWABI
? 3 : 2);
2894 mips_regmask_frag
= frag_more (sizeof (Elf32_External_RegInfo
));
2898 /* The 64-bit ABI uses a .MIPS.options section rather than
2899 .reginfo section. */
2900 sec
= subseg_new (".MIPS.options", (subsegT
) 0);
2901 bfd_set_section_flags (stdoutput
, sec
, flags
);
2902 bfd_set_section_alignment (stdoutput
, sec
, 3);
2904 /* Set up the option header. */
2906 Elf_Internal_Options opthdr
;
2909 opthdr
.kind
= ODK_REGINFO
;
2910 opthdr
.size
= (sizeof (Elf_External_Options
)
2911 + sizeof (Elf64_External_RegInfo
));
2914 f
= frag_more (sizeof (Elf_External_Options
));
2915 bfd_mips_elf_swap_options_out (stdoutput
, &opthdr
,
2916 (Elf_External_Options
*) f
);
2918 mips_regmask_frag
= frag_more (sizeof (Elf64_External_RegInfo
));
2922 if (ECOFF_DEBUGGING
)
2924 sec
= subseg_new (".mdebug", (subsegT
) 0);
2925 (void) bfd_set_section_flags (stdoutput
, sec
,
2926 SEC_HAS_CONTENTS
| SEC_READONLY
);
2927 (void) bfd_set_section_alignment (stdoutput
, sec
, 2);
2929 else if (mips_flag_pdr
)
2931 pdr_seg
= subseg_new (".pdr", (subsegT
) 0);
2932 (void) bfd_set_section_flags (stdoutput
, pdr_seg
,
2933 SEC_READONLY
| SEC_RELOC
2935 (void) bfd_set_section_alignment (stdoutput
, pdr_seg
, 2);
2938 subseg_set (seg
, subseg
);
2941 if (! ECOFF_DEBUGGING
)
2944 if (mips_fix_vr4120
)
2945 init_vr4120_conflicts ();
2951 mips_emit_delays ();
2952 if (! ECOFF_DEBUGGING
)
2957 md_assemble (char *str
)
2959 struct mips_cl_insn insn
;
2960 bfd_reloc_code_real_type unused_reloc
[3]
2961 = {BFD_RELOC_UNUSED
, BFD_RELOC_UNUSED
, BFD_RELOC_UNUSED
};
2963 imm_expr
.X_op
= O_absent
;
2964 imm2_expr
.X_op
= O_absent
;
2965 offset_expr
.X_op
= O_absent
;
2966 imm_reloc
[0] = BFD_RELOC_UNUSED
;
2967 imm_reloc
[1] = BFD_RELOC_UNUSED
;
2968 imm_reloc
[2] = BFD_RELOC_UNUSED
;
2969 offset_reloc
[0] = BFD_RELOC_UNUSED
;
2970 offset_reloc
[1] = BFD_RELOC_UNUSED
;
2971 offset_reloc
[2] = BFD_RELOC_UNUSED
;
2973 mips_mark_labels ();
2974 mips_assembling_insn
= TRUE
;
2976 if (mips_opts
.mips16
)
2977 mips16_ip (str
, &insn
);
2980 mips_ip (str
, &insn
);
2981 DBG ((_("returned from mips_ip(%s) insn_opcode = 0x%x\n"),
2982 str
, insn
.insn_opcode
));
2986 as_bad ("%s `%s'", insn_error
, str
);
2987 else if (insn
.insn_mo
->pinfo
== INSN_MACRO
)
2990 if (mips_opts
.mips16
)
2991 mips16_macro (&insn
);
2998 if (imm_expr
.X_op
!= O_absent
)
2999 append_insn (&insn
, &imm_expr
, imm_reloc
, FALSE
);
3000 else if (offset_expr
.X_op
!= O_absent
)
3001 append_insn (&insn
, &offset_expr
, offset_reloc
, FALSE
);
3003 append_insn (&insn
, NULL
, unused_reloc
, FALSE
);
3006 mips_assembling_insn
= FALSE
;
3009 /* Convenience functions for abstracting away the differences between
3010 MIPS16 and non-MIPS16 relocations. */
3012 static inline bfd_boolean
3013 mips16_reloc_p (bfd_reloc_code_real_type reloc
)
3017 case BFD_RELOC_MIPS16_JMP
:
3018 case BFD_RELOC_MIPS16_GPREL
:
3019 case BFD_RELOC_MIPS16_GOT16
:
3020 case BFD_RELOC_MIPS16_CALL16
:
3021 case BFD_RELOC_MIPS16_HI16_S
:
3022 case BFD_RELOC_MIPS16_HI16
:
3023 case BFD_RELOC_MIPS16_LO16
:
3031 static inline bfd_boolean
3032 micromips_reloc_p (bfd_reloc_code_real_type reloc
)
3036 case BFD_RELOC_MICROMIPS_7_PCREL_S1
:
3037 case BFD_RELOC_MICROMIPS_10_PCREL_S1
:
3038 case BFD_RELOC_MICROMIPS_16_PCREL_S1
:
3039 case BFD_RELOC_MICROMIPS_GPREL16
:
3040 case BFD_RELOC_MICROMIPS_JMP
:
3041 case BFD_RELOC_MICROMIPS_HI16
:
3042 case BFD_RELOC_MICROMIPS_HI16_S
:
3043 case BFD_RELOC_MICROMIPS_LO16
:
3044 case BFD_RELOC_MICROMIPS_LITERAL
:
3045 case BFD_RELOC_MICROMIPS_GOT16
:
3046 case BFD_RELOC_MICROMIPS_CALL16
:
3047 case BFD_RELOC_MICROMIPS_GOT_HI16
:
3048 case BFD_RELOC_MICROMIPS_GOT_LO16
:
3049 case BFD_RELOC_MICROMIPS_CALL_HI16
:
3050 case BFD_RELOC_MICROMIPS_CALL_LO16
:
3051 case BFD_RELOC_MICROMIPS_SUB
:
3052 case BFD_RELOC_MICROMIPS_GOT_PAGE
:
3053 case BFD_RELOC_MICROMIPS_GOT_OFST
:
3054 case BFD_RELOC_MICROMIPS_GOT_DISP
:
3055 case BFD_RELOC_MICROMIPS_HIGHEST
:
3056 case BFD_RELOC_MICROMIPS_HIGHER
:
3057 case BFD_RELOC_MICROMIPS_SCN_DISP
:
3058 case BFD_RELOC_MICROMIPS_JALR
:
3066 static inline bfd_boolean
3067 jmp_reloc_p (bfd_reloc_code_real_type reloc
)
3069 return reloc
== BFD_RELOC_MIPS_JMP
|| reloc
== BFD_RELOC_MICROMIPS_JMP
;
3072 static inline bfd_boolean
3073 got16_reloc_p (bfd_reloc_code_real_type reloc
)
3075 return (reloc
== BFD_RELOC_MIPS_GOT16
|| reloc
== BFD_RELOC_MIPS16_GOT16
3076 || reloc
== BFD_RELOC_MICROMIPS_GOT16
);
3079 static inline bfd_boolean
3080 hi16_reloc_p (bfd_reloc_code_real_type reloc
)
3082 return (reloc
== BFD_RELOC_HI16_S
|| reloc
== BFD_RELOC_MIPS16_HI16_S
3083 || reloc
== BFD_RELOC_MICROMIPS_HI16_S
);
3086 static inline bfd_boolean
3087 lo16_reloc_p (bfd_reloc_code_real_type reloc
)
3089 return (reloc
== BFD_RELOC_LO16
|| reloc
== BFD_RELOC_MIPS16_LO16
3090 || reloc
== BFD_RELOC_MICROMIPS_LO16
);
3093 static inline bfd_boolean
3094 jalr_reloc_p (bfd_reloc_code_real_type reloc
)
3096 return reloc
== BFD_RELOC_MIPS_JALR
|| reloc
== BFD_RELOC_MICROMIPS_JALR
;
3099 /* Return true if RELOC is a PC-relative relocation that does not have
3100 full address range. */
3102 static inline bfd_boolean
3103 limited_pcrel_reloc_p (bfd_reloc_code_real_type reloc
)
3107 case BFD_RELOC_16_PCREL_S2
:
3108 case BFD_RELOC_MICROMIPS_7_PCREL_S1
:
3109 case BFD_RELOC_MICROMIPS_10_PCREL_S1
:
3110 case BFD_RELOC_MICROMIPS_16_PCREL_S1
:
3113 case BFD_RELOC_32_PCREL
:
3114 return HAVE_64BIT_ADDRESSES
;
3121 /* Return true if the given relocation might need a matching %lo().
3122 This is only "might" because SVR4 R_MIPS_GOT16 relocations only
3123 need a matching %lo() when applied to local symbols. */
3125 static inline bfd_boolean
3126 reloc_needs_lo_p (bfd_reloc_code_real_type reloc
)
3128 return (HAVE_IN_PLACE_ADDENDS
3129 && (hi16_reloc_p (reloc
)
3130 /* VxWorks R_MIPS_GOT16 relocs never need a matching %lo();
3131 all GOT16 relocations evaluate to "G". */
3132 || (got16_reloc_p (reloc
) && mips_pic
!= VXWORKS_PIC
)));
3135 /* Return the type of %lo() reloc needed by RELOC, given that
3136 reloc_needs_lo_p. */
3138 static inline bfd_reloc_code_real_type
3139 matching_lo_reloc (bfd_reloc_code_real_type reloc
)
3141 return (mips16_reloc_p (reloc
) ? BFD_RELOC_MIPS16_LO16
3142 : (micromips_reloc_p (reloc
) ? BFD_RELOC_MICROMIPS_LO16
3146 /* Return true if the given fixup is followed by a matching R_MIPS_LO16
3149 static inline bfd_boolean
3150 fixup_has_matching_lo_p (fixS
*fixp
)
3152 return (fixp
->fx_next
!= NULL
3153 && fixp
->fx_next
->fx_r_type
== matching_lo_reloc (fixp
->fx_r_type
)
3154 && fixp
->fx_addsy
== fixp
->fx_next
->fx_addsy
3155 && fixp
->fx_offset
== fixp
->fx_next
->fx_offset
);
3158 /* This function returns true if modifying a register requires a
3162 reg_needs_delay (unsigned int reg
)
3164 unsigned long prev_pinfo
;
3166 prev_pinfo
= history
[0].insn_mo
->pinfo
;
3167 if (! mips_opts
.noreorder
3168 && (((prev_pinfo
& INSN_LOAD_MEMORY_DELAY
)
3169 && ! gpr_interlocks
)
3170 || ((prev_pinfo
& INSN_LOAD_COPROC_DELAY
)
3171 && ! cop_interlocks
)))
3173 /* A load from a coprocessor or from memory. All load delays
3174 delay the use of general register rt for one instruction. */
3175 /* Itbl support may require additional care here. */
3176 know (prev_pinfo
& INSN_WRITE_GPR_T
);
3177 if (reg
== EXTRACT_OPERAND (mips_opts
.micromips
, RT
, history
[0]))
3184 /* Move all labels in LABELS to the current insertion point. TEXT_P
3185 says whether the labels refer to text or data. */
3188 mips_move_labels (struct insn_label_list
*labels
, bfd_boolean text_p
)
3190 struct insn_label_list
*l
;
3193 for (l
= labels
; l
!= NULL
; l
= l
->next
)
3195 gas_assert (S_GET_SEGMENT (l
->label
) == now_seg
);
3196 symbol_set_frag (l
->label
, frag_now
);
3197 val
= (valueT
) frag_now_fix ();
3198 /* MIPS16/microMIPS text labels are stored as odd. */
3199 if (text_p
&& HAVE_CODE_COMPRESSION
)
3201 S_SET_VALUE (l
->label
, val
);
3205 /* Move all labels in insn_labels to the current insertion point
3206 and treat them as text labels. */
3209 mips_move_text_labels (void)
3211 mips_move_labels (seg_info (now_seg
)->label_list
, TRUE
);
3215 s_is_linkonce (symbolS
*sym
, segT from_seg
)
3217 bfd_boolean linkonce
= FALSE
;
3218 segT symseg
= S_GET_SEGMENT (sym
);
3220 if (symseg
!= from_seg
&& !S_IS_LOCAL (sym
))
3222 if ((bfd_get_section_flags (stdoutput
, symseg
) & SEC_LINK_ONCE
))
3224 /* The GNU toolchain uses an extension for ELF: a section
3225 beginning with the magic string .gnu.linkonce is a
3226 linkonce section. */
3227 if (strncmp (segment_name (symseg
), ".gnu.linkonce",
3228 sizeof ".gnu.linkonce" - 1) == 0)
3234 /* Mark MIPS16 or microMIPS instruction label LABEL. This permits the
3235 linker to handle them specially, such as generating jalx instructions
3236 when needed. We also make them odd for the duration of the assembly,
3237 in order to generate the right sort of code. We will make them even
3238 in the adjust_symtab routine, while leaving them marked. This is
3239 convenient for the debugger and the disassembler. The linker knows
3240 to make them odd again. */
3243 mips_compressed_mark_label (symbolS
*label
)
3245 gas_assert (HAVE_CODE_COMPRESSION
);
3247 if (mips_opts
.mips16
)
3248 S_SET_OTHER (label
, ELF_ST_SET_MIPS16 (S_GET_OTHER (label
)));
3250 S_SET_OTHER (label
, ELF_ST_SET_MICROMIPS (S_GET_OTHER (label
)));
3251 if ((S_GET_VALUE (label
) & 1) == 0
3252 /* Don't adjust the address if the label is global or weak, or
3253 in a link-once section, since we'll be emitting symbol reloc
3254 references to it which will be patched up by the linker, and
3255 the final value of the symbol may or may not be MIPS16/microMIPS. */
3256 && !S_IS_WEAK (label
)
3257 && !S_IS_EXTERNAL (label
)
3258 && !s_is_linkonce (label
, now_seg
))
3259 S_SET_VALUE (label
, S_GET_VALUE (label
) | 1);
3262 /* Mark preceding MIPS16 or microMIPS instruction labels. */
3265 mips_compressed_mark_labels (void)
3267 struct insn_label_list
*l
;
3269 for (l
= seg_info (now_seg
)->label_list
; l
!= NULL
; l
= l
->next
)
3270 mips_compressed_mark_label (l
->label
);
3273 /* End the current frag. Make it a variant frag and record the
3277 relax_close_frag (void)
3279 mips_macro_warning
.first_frag
= frag_now
;
3280 frag_var (rs_machine_dependent
, 0, 0,
3281 RELAX_ENCODE (mips_relax
.sizes
[0], mips_relax
.sizes
[1]),
3282 mips_relax
.symbol
, 0, (char *) mips_relax
.first_fixup
);
3284 memset (&mips_relax
.sizes
, 0, sizeof (mips_relax
.sizes
));
3285 mips_relax
.first_fixup
= 0;
3288 /* Start a new relaxation sequence whose expansion depends on SYMBOL.
3289 See the comment above RELAX_ENCODE for more details. */
3292 relax_start (symbolS
*symbol
)
3294 gas_assert (mips_relax
.sequence
== 0);
3295 mips_relax
.sequence
= 1;
3296 mips_relax
.symbol
= symbol
;
3299 /* Start generating the second version of a relaxable sequence.
3300 See the comment above RELAX_ENCODE for more details. */
3305 gas_assert (mips_relax
.sequence
== 1);
3306 mips_relax
.sequence
= 2;
3309 /* End the current relaxable sequence. */
3314 gas_assert (mips_relax
.sequence
== 2);
3315 relax_close_frag ();
3316 mips_relax
.sequence
= 0;
3319 /* Return true if IP is a delayed branch or jump. */
3321 static inline bfd_boolean
3322 delayed_branch_p (const struct mips_cl_insn
*ip
)
3324 return (ip
->insn_mo
->pinfo
& (INSN_UNCOND_BRANCH_DELAY
3325 | INSN_COND_BRANCH_DELAY
3326 | INSN_COND_BRANCH_LIKELY
)) != 0;
3329 /* Return true if IP is a compact branch or jump. */
3331 static inline bfd_boolean
3332 compact_branch_p (const struct mips_cl_insn
*ip
)
3334 if (mips_opts
.mips16
)
3335 return (ip
->insn_mo
->pinfo
& (MIPS16_INSN_UNCOND_BRANCH
3336 | MIPS16_INSN_COND_BRANCH
)) != 0;
3338 return (ip
->insn_mo
->pinfo2
& (INSN2_UNCOND_BRANCH
3339 | INSN2_COND_BRANCH
)) != 0;
3342 /* Return true if IP is an unconditional branch or jump. */
3344 static inline bfd_boolean
3345 uncond_branch_p (const struct mips_cl_insn
*ip
)
3347 return ((ip
->insn_mo
->pinfo
& INSN_UNCOND_BRANCH_DELAY
) != 0
3348 || (mips_opts
.mips16
3349 ? (ip
->insn_mo
->pinfo
& MIPS16_INSN_UNCOND_BRANCH
) != 0
3350 : (ip
->insn_mo
->pinfo2
& INSN2_UNCOND_BRANCH
) != 0));
3353 /* Return true if IP is a branch-likely instruction. */
3355 static inline bfd_boolean
3356 branch_likely_p (const struct mips_cl_insn
*ip
)
3358 return (ip
->insn_mo
->pinfo
& INSN_COND_BRANCH_LIKELY
) != 0;
3361 /* Return the type of nop that should be used to fill the delay slot
3362 of delayed branch IP. */
3364 static struct mips_cl_insn
*
3365 get_delay_slot_nop (const struct mips_cl_insn
*ip
)
3367 if (mips_opts
.micromips
3368 && (ip
->insn_mo
->pinfo2
& INSN2_BRANCH_DELAY_32BIT
))
3369 return µmips_nop32_insn
;
3373 /* Return the mask of core registers that IP reads or writes. */
3376 gpr_mod_mask (const struct mips_cl_insn
*ip
)
3378 unsigned long pinfo2
;
3382 pinfo2
= ip
->insn_mo
->pinfo2
;
3383 if (mips_opts
.micromips
)
3385 if (pinfo2
& INSN2_MOD_GPR_MD
)
3386 mask
|= 1 << micromips_to_32_reg_d_map
[EXTRACT_OPERAND (1, MD
, *ip
)];
3387 if (pinfo2
& INSN2_MOD_GPR_MF
)
3388 mask
|= 1 << micromips_to_32_reg_f_map
[EXTRACT_OPERAND (1, MF
, *ip
)];
3389 if (pinfo2
& INSN2_MOD_SP
)
3395 /* Return the mask of core registers that IP reads. */
3398 gpr_read_mask (const struct mips_cl_insn
*ip
)
3400 unsigned long pinfo
, pinfo2
;
3403 mask
= gpr_mod_mask (ip
);
3404 pinfo
= ip
->insn_mo
->pinfo
;
3405 pinfo2
= ip
->insn_mo
->pinfo2
;
3406 if (mips_opts
.mips16
)
3408 if (pinfo
& MIPS16_INSN_READ_X
)
3409 mask
|= 1 << mips16_to_32_reg_map
[MIPS16_EXTRACT_OPERAND (RX
, *ip
)];
3410 if (pinfo
& MIPS16_INSN_READ_Y
)
3411 mask
|= 1 << mips16_to_32_reg_map
[MIPS16_EXTRACT_OPERAND (RY
, *ip
)];
3412 if (pinfo
& MIPS16_INSN_READ_T
)
3414 if (pinfo
& MIPS16_INSN_READ_SP
)
3416 if (pinfo
& MIPS16_INSN_READ_31
)
3418 if (pinfo
& MIPS16_INSN_READ_Z
)
3419 mask
|= 1 << (mips16_to_32_reg_map
3420 [MIPS16_EXTRACT_OPERAND (MOVE32Z
, *ip
)]);
3421 if (pinfo
& MIPS16_INSN_READ_GPR_X
)
3422 mask
|= 1 << MIPS16_EXTRACT_OPERAND (REGR32
, *ip
);
3426 if (pinfo2
& INSN2_READ_GPR_D
)
3427 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, RD
, *ip
);
3428 if (pinfo
& INSN_READ_GPR_T
)
3429 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, RT
, *ip
);
3430 if (pinfo
& INSN_READ_GPR_S
)
3431 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, RS
, *ip
);
3432 if (pinfo2
& INSN2_READ_GP
)
3434 if (pinfo2
& INSN2_READ_GPR_31
)
3436 if (pinfo2
& INSN2_READ_GPR_Z
)
3437 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, RZ
, *ip
);
3439 if (mips_opts
.micromips
)
3441 if (pinfo2
& INSN2_READ_GPR_MC
)
3442 mask
|= 1 << micromips_to_32_reg_c_map
[EXTRACT_OPERAND (1, MC
, *ip
)];
3443 if (pinfo2
& INSN2_READ_GPR_ME
)
3444 mask
|= 1 << micromips_to_32_reg_e_map
[EXTRACT_OPERAND (1, ME
, *ip
)];
3445 if (pinfo2
& INSN2_READ_GPR_MG
)
3446 mask
|= 1 << micromips_to_32_reg_g_map
[EXTRACT_OPERAND (1, MG
, *ip
)];
3447 if (pinfo2
& INSN2_READ_GPR_MJ
)
3448 mask
|= 1 << EXTRACT_OPERAND (1, MJ
, *ip
);
3449 if (pinfo2
& INSN2_READ_GPR_MMN
)
3451 mask
|= 1 << micromips_to_32_reg_m_map
[EXTRACT_OPERAND (1, MM
, *ip
)];
3452 mask
|= 1 << micromips_to_32_reg_n_map
[EXTRACT_OPERAND (1, MN
, *ip
)];
3454 if (pinfo2
& INSN2_READ_GPR_MP
)
3455 mask
|= 1 << EXTRACT_OPERAND (1, MP
, *ip
);
3456 if (pinfo2
& INSN2_READ_GPR_MQ
)
3457 mask
|= 1 << micromips_to_32_reg_q_map
[EXTRACT_OPERAND (1, MQ
, *ip
)];
3459 /* Don't include register 0. */
3463 /* Return the mask of core registers that IP writes. */
3466 gpr_write_mask (const struct mips_cl_insn
*ip
)
3468 unsigned long pinfo
, pinfo2
;
3471 mask
= gpr_mod_mask (ip
);
3472 pinfo
= ip
->insn_mo
->pinfo
;
3473 pinfo2
= ip
->insn_mo
->pinfo2
;
3474 if (mips_opts
.mips16
)
3476 if (pinfo
& MIPS16_INSN_WRITE_X
)
3477 mask
|= 1 << mips16_to_32_reg_map
[MIPS16_EXTRACT_OPERAND (RX
, *ip
)];
3478 if (pinfo
& MIPS16_INSN_WRITE_Y
)
3479 mask
|= 1 << mips16_to_32_reg_map
[MIPS16_EXTRACT_OPERAND (RY
, *ip
)];
3480 if (pinfo
& MIPS16_INSN_WRITE_Z
)
3481 mask
|= 1 << mips16_to_32_reg_map
[MIPS16_EXTRACT_OPERAND (RZ
, *ip
)];
3482 if (pinfo
& MIPS16_INSN_WRITE_T
)
3484 if (pinfo
& MIPS16_INSN_WRITE_SP
)
3486 if (pinfo
& MIPS16_INSN_WRITE_31
)
3488 if (pinfo
& MIPS16_INSN_WRITE_GPR_Y
)
3489 mask
|= 1 << MIPS16OP_EXTRACT_REG32R (ip
->insn_opcode
);
3493 if (pinfo
& INSN_WRITE_GPR_D
)
3494 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, RD
, *ip
);
3495 if (pinfo
& INSN_WRITE_GPR_T
)
3496 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, RT
, *ip
);
3497 if (pinfo
& INSN_WRITE_GPR_S
)
3498 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, RS
, *ip
);
3499 if (pinfo
& INSN_WRITE_GPR_31
)
3501 if (pinfo2
& INSN2_WRITE_GPR_Z
)
3502 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, RZ
, *ip
);
3504 if (mips_opts
.micromips
)
3506 if (pinfo2
& INSN2_WRITE_GPR_MB
)
3507 mask
|= 1 << micromips_to_32_reg_b_map
[EXTRACT_OPERAND (1, MB
, *ip
)];
3508 if (pinfo2
& INSN2_WRITE_GPR_MH
)
3510 mask
|= 1 << micromips_to_32_reg_h_map1
[EXTRACT_OPERAND (1, MH
, *ip
)];
3511 mask
|= 1 << micromips_to_32_reg_h_map2
[EXTRACT_OPERAND (1, MH
, *ip
)];
3513 if (pinfo2
& INSN2_WRITE_GPR_MJ
)
3514 mask
|= 1 << EXTRACT_OPERAND (1, MJ
, *ip
);
3515 if (pinfo2
& INSN2_WRITE_GPR_MP
)
3516 mask
|= 1 << EXTRACT_OPERAND (1, MP
, *ip
);
3518 /* Don't include register 0. */
3522 /* Return the mask of floating-point registers that IP reads. */
3525 fpr_read_mask (const struct mips_cl_insn
*ip
)
3527 unsigned long pinfo
, pinfo2
;
3531 pinfo
= ip
->insn_mo
->pinfo
;
3532 pinfo2
= ip
->insn_mo
->pinfo2
;
3533 if (!mips_opts
.mips16
)
3535 if (pinfo2
& INSN2_READ_FPR_D
)
3536 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, FD
, *ip
);
3537 if (pinfo
& INSN_READ_FPR_S
)
3538 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, FS
, *ip
);
3539 if (pinfo
& INSN_READ_FPR_T
)
3540 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, FT
, *ip
);
3541 if (pinfo
& INSN_READ_FPR_R
)
3542 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, FR
, *ip
);
3543 if (pinfo2
& INSN2_READ_FPR_Z
)
3544 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, FZ
, *ip
);
3546 /* Conservatively treat all operands to an FP_D instruction are doubles.
3547 (This is overly pessimistic for things like cvt.d.s.) */
3548 if (HAVE_32BIT_FPRS
&& (pinfo
& FP_D
))
3553 /* Return the mask of floating-point registers that IP writes. */
3556 fpr_write_mask (const struct mips_cl_insn
*ip
)
3558 unsigned long pinfo
, pinfo2
;
3562 pinfo
= ip
->insn_mo
->pinfo
;
3563 pinfo2
= ip
->insn_mo
->pinfo2
;
3564 if (!mips_opts
.mips16
)
3566 if (pinfo
& INSN_WRITE_FPR_D
)
3567 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, FD
, *ip
);
3568 if (pinfo
& INSN_WRITE_FPR_S
)
3569 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, FS
, *ip
);
3570 if (pinfo
& INSN_WRITE_FPR_T
)
3571 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, FT
, *ip
);
3572 if (pinfo2
& INSN2_WRITE_FPR_Z
)
3573 mask
|= 1 << EXTRACT_OPERAND (mips_opts
.micromips
, FZ
, *ip
);
3575 /* Conservatively treat all operands to an FP_D instruction are doubles.
3576 (This is overly pessimistic for things like cvt.s.d.) */
3577 if (HAVE_32BIT_FPRS
&& (pinfo
& FP_D
))
3582 /* Classify an instruction according to the FIX_VR4120_* enumeration.
3583 Return NUM_FIX_VR4120_CLASSES if the instruction isn't affected
3584 by VR4120 errata. */
3587 classify_vr4120_insn (const char *name
)
3589 if (strncmp (name
, "macc", 4) == 0)
3590 return FIX_VR4120_MACC
;
3591 if (strncmp (name
, "dmacc", 5) == 0)
3592 return FIX_VR4120_DMACC
;
3593 if (strncmp (name
, "mult", 4) == 0)
3594 return FIX_VR4120_MULT
;
3595 if (strncmp (name
, "dmult", 5) == 0)
3596 return FIX_VR4120_DMULT
;
3597 if (strstr (name
, "div"))
3598 return FIX_VR4120_DIV
;
3599 if (strcmp (name
, "mtlo") == 0 || strcmp (name
, "mthi") == 0)
3600 return FIX_VR4120_MTHILO
;
3601 return NUM_FIX_VR4120_CLASSES
;
3604 #define INSN_ERET 0x42000018
3605 #define INSN_DERET 0x4200001f
3607 /* Return the number of instructions that must separate INSN1 and INSN2,
3608 where INSN1 is the earlier instruction. Return the worst-case value
3609 for any INSN2 if INSN2 is null. */
3612 insns_between (const struct mips_cl_insn
*insn1
,
3613 const struct mips_cl_insn
*insn2
)
3615 unsigned long pinfo1
, pinfo2
;
3618 /* This function needs to know which pinfo flags are set for INSN2
3619 and which registers INSN2 uses. The former is stored in PINFO2 and
3620 the latter is tested via INSN2_USES_GPR. If INSN2 is null, PINFO2
3621 will have every flag set and INSN2_USES_GPR will always return true. */
3622 pinfo1
= insn1
->insn_mo
->pinfo
;
3623 pinfo2
= insn2
? insn2
->insn_mo
->pinfo
: ~0U;
3625 #define INSN2_USES_GPR(REG) \
3626 (insn2 == NULL || (gpr_read_mask (insn2) & (1U << (REG))) != 0)
3628 /* For most targets, write-after-read dependencies on the HI and LO
3629 registers must be separated by at least two instructions. */
3630 if (!hilo_interlocks
)
3632 if ((pinfo1
& INSN_READ_LO
) && (pinfo2
& INSN_WRITE_LO
))
3634 if ((pinfo1
& INSN_READ_HI
) && (pinfo2
& INSN_WRITE_HI
))
3638 /* If we're working around r7000 errata, there must be two instructions
3639 between an mfhi or mflo and any instruction that uses the result. */
3640 if (mips_7000_hilo_fix
3641 && !mips_opts
.micromips
3642 && MF_HILO_INSN (pinfo1
)
3643 && INSN2_USES_GPR (EXTRACT_OPERAND (0, RD
, *insn1
)))
3646 /* If we're working around 24K errata, one instruction is required
3647 if an ERET or DERET is followed by a branch instruction. */
3648 if (mips_fix_24k
&& !mips_opts
.micromips
)
3650 if (insn1
->insn_opcode
== INSN_ERET
3651 || insn1
->insn_opcode
== INSN_DERET
)
3654 || insn2
->insn_opcode
== INSN_ERET
3655 || insn2
->insn_opcode
== INSN_DERET
3656 || delayed_branch_p (insn2
))
3661 /* If working around VR4120 errata, check for combinations that need
3662 a single intervening instruction. */
3663 if (mips_fix_vr4120
&& !mips_opts
.micromips
)
3665 unsigned int class1
, class2
;
3667 class1
= classify_vr4120_insn (insn1
->insn_mo
->name
);
3668 if (class1
!= NUM_FIX_VR4120_CLASSES
&& vr4120_conflicts
[class1
] != 0)
3672 class2
= classify_vr4120_insn (insn2
->insn_mo
->name
);
3673 if (vr4120_conflicts
[class1
] & (1 << class2
))
3678 if (!HAVE_CODE_COMPRESSION
)
3680 /* Check for GPR or coprocessor load delays. All such delays
3681 are on the RT register. */
3682 /* Itbl support may require additional care here. */
3683 if ((!gpr_interlocks
&& (pinfo1
& INSN_LOAD_MEMORY_DELAY
))
3684 || (!cop_interlocks
&& (pinfo1
& INSN_LOAD_COPROC_DELAY
)))
3686 know (pinfo1
& INSN_WRITE_GPR_T
);
3687 if (INSN2_USES_GPR (EXTRACT_OPERAND (0, RT
, *insn1
)))
3691 /* Check for generic coprocessor hazards.
3693 This case is not handled very well. There is no special
3694 knowledge of CP0 handling, and the coprocessors other than
3695 the floating point unit are not distinguished at all. */
3696 /* Itbl support may require additional care here. FIXME!
3697 Need to modify this to include knowledge about
3698 user specified delays! */
3699 else if ((!cop_interlocks
&& (pinfo1
& INSN_COPROC_MOVE_DELAY
))
3700 || (!cop_mem_interlocks
&& (pinfo1
& INSN_COPROC_MEMORY_DELAY
)))
3702 /* Handle cases where INSN1 writes to a known general coprocessor
3703 register. There must be a one instruction delay before INSN2
3704 if INSN2 reads that register, otherwise no delay is needed. */
3705 mask
= fpr_write_mask (insn1
);
3708 if (!insn2
|| (mask
& fpr_read_mask (insn2
)) != 0)
3713 /* Read-after-write dependencies on the control registers
3714 require a two-instruction gap. */
3715 if ((pinfo1
& INSN_WRITE_COND_CODE
)
3716 && (pinfo2
& INSN_READ_COND_CODE
))
3719 /* We don't know exactly what INSN1 does. If INSN2 is
3720 also a coprocessor instruction, assume there must be
3721 a one instruction gap. */
3722 if (pinfo2
& INSN_COP
)
3727 /* Check for read-after-write dependencies on the coprocessor
3728 control registers in cases where INSN1 does not need a general
3729 coprocessor delay. This means that INSN1 is a floating point
3730 comparison instruction. */
3731 /* Itbl support may require additional care here. */
3732 else if (!cop_interlocks
3733 && (pinfo1
& INSN_WRITE_COND_CODE
)
3734 && (pinfo2
& INSN_READ_COND_CODE
))
3738 #undef INSN2_USES_GPR
3743 /* Return the number of nops that would be needed to work around the
3744 VR4130 mflo/mfhi errata if instruction INSN immediately followed
3745 the MAX_VR4130_NOPS instructions described by HIST. Ignore hazards
3746 that are contained within the first IGNORE instructions of HIST. */
3749 nops_for_vr4130 (int ignore
, const struct mips_cl_insn
*hist
,
3750 const struct mips_cl_insn
*insn
)
3755 /* Check if the instruction writes to HI or LO. MTHI and MTLO
3756 are not affected by the errata. */
3758 && ((insn
->insn_mo
->pinfo
& (INSN_WRITE_HI
| INSN_WRITE_LO
)) == 0
3759 || strcmp (insn
->insn_mo
->name
, "mtlo") == 0
3760 || strcmp (insn
->insn_mo
->name
, "mthi") == 0))
3763 /* Search for the first MFLO or MFHI. */
3764 for (i
= 0; i
< MAX_VR4130_NOPS
; i
++)
3765 if (MF_HILO_INSN (hist
[i
].insn_mo
->pinfo
))
3767 /* Extract the destination register. */
3768 mask
= gpr_write_mask (&hist
[i
]);
3770 /* No nops are needed if INSN reads that register. */
3771 if (insn
!= NULL
&& (gpr_read_mask (insn
) & mask
) != 0)
3774 /* ...or if any of the intervening instructions do. */
3775 for (j
= 0; j
< i
; j
++)
3776 if (gpr_read_mask (&hist
[j
]) & mask
)
3780 return MAX_VR4130_NOPS
- i
;
3785 #define BASE_REG_EQ(INSN1, INSN2) \
3786 ((((INSN1) >> OP_SH_RS) & OP_MASK_RS) \
3787 == (((INSN2) >> OP_SH_RS) & OP_MASK_RS))
3789 /* Return the minimum alignment for this store instruction. */
3792 fix_24k_align_to (const struct mips_opcode
*mo
)
3794 if (strcmp (mo
->name
, "sh") == 0)
3797 if (strcmp (mo
->name
, "swc1") == 0
3798 || strcmp (mo
->name
, "swc2") == 0
3799 || strcmp (mo
->name
, "sw") == 0
3800 || strcmp (mo
->name
, "sc") == 0
3801 || strcmp (mo
->name
, "s.s") == 0)
3804 if (strcmp (mo
->name
, "sdc1") == 0
3805 || strcmp (mo
->name
, "sdc2") == 0
3806 || strcmp (mo
->name
, "s.d") == 0)
3813 struct fix_24k_store_info
3815 /* Immediate offset, if any, for this store instruction. */
3817 /* Alignment required by this store instruction. */
3819 /* True for register offsets. */
3820 int register_offset
;
3823 /* Comparison function used by qsort. */
3826 fix_24k_sort (const void *a
, const void *b
)
3828 const struct fix_24k_store_info
*pos1
= a
;
3829 const struct fix_24k_store_info
*pos2
= b
;
3831 return (pos1
->off
- pos2
->off
);
3834 /* INSN is a store instruction. Try to record the store information
3835 in STINFO. Return false if the information isn't known. */
3838 fix_24k_record_store_info (struct fix_24k_store_info
*stinfo
,
3839 const struct mips_cl_insn
*insn
)
3841 /* The instruction must have a known offset. */
3842 if (!insn
->complete_p
|| !strstr (insn
->insn_mo
->args
, "o("))
3845 stinfo
->off
= (insn
->insn_opcode
>> OP_SH_IMMEDIATE
) & OP_MASK_IMMEDIATE
;
3846 stinfo
->align_to
= fix_24k_align_to (insn
->insn_mo
);
3850 /* Return the number of nops that would be needed to work around the 24k
3851 "lost data on stores during refill" errata if instruction INSN
3852 immediately followed the 2 instructions described by HIST.
3853 Ignore hazards that are contained within the first IGNORE
3854 instructions of HIST.
3856 Problem: The FSB (fetch store buffer) acts as an intermediate buffer
3857 for the data cache refills and store data. The following describes
3858 the scenario where the store data could be lost.
3860 * A data cache miss, due to either a load or a store, causing fill
3861 data to be supplied by the memory subsystem
3862 * The first three doublewords of fill data are returned and written
3864 * A sequence of four stores occurs in consecutive cycles around the
3865 final doubleword of the fill:
3869 * Zero, One or more instructions
3872 The four stores A-D must be to different doublewords of the line that
3873 is being filled. The fourth instruction in the sequence above permits
3874 the fill of the final doubleword to be transferred from the FSB into
3875 the cache. In the sequence above, the stores may be either integer
3876 (sb, sh, sw, swr, swl, sc) or coprocessor (swc1/swc2, sdc1/sdc2,
3877 swxc1, sdxc1, suxc1) stores, as long as the four stores are to
3878 different doublewords on the line. If the floating point unit is
3879 running in 1:2 mode, it is not possible to create the sequence above
3880 using only floating point store instructions.
3882 In this case, the cache line being filled is incorrectly marked
3883 invalid, thereby losing the data from any store to the line that
3884 occurs between the original miss and the completion of the five
3885 cycle sequence shown above.
3887 The workarounds are:
3889 * Run the data cache in write-through mode.
3890 * Insert a non-store instruction between
3891 Store A and Store B or Store B and Store C. */
3894 nops_for_24k (int ignore
, const struct mips_cl_insn
*hist
,
3895 const struct mips_cl_insn
*insn
)
3897 struct fix_24k_store_info pos
[3];
3898 int align
, i
, base_offset
;
3903 /* If the previous instruction wasn't a store, there's nothing to
3905 if ((hist
[0].insn_mo
->pinfo
& INSN_STORE_MEMORY
) == 0)
3908 /* If the instructions after the previous one are unknown, we have
3909 to assume the worst. */
3913 /* Check whether we are dealing with three consecutive stores. */
3914 if ((insn
->insn_mo
->pinfo
& INSN_STORE_MEMORY
) == 0
3915 || (hist
[1].insn_mo
->pinfo
& INSN_STORE_MEMORY
) == 0)
3918 /* If we don't know the relationship between the store addresses,
3919 assume the worst. */
3920 if (!BASE_REG_EQ (insn
->insn_opcode
, hist
[0].insn_opcode
)
3921 || !BASE_REG_EQ (insn
->insn_opcode
, hist
[1].insn_opcode
))
3924 if (!fix_24k_record_store_info (&pos
[0], insn
)
3925 || !fix_24k_record_store_info (&pos
[1], &hist
[0])
3926 || !fix_24k_record_store_info (&pos
[2], &hist
[1]))
3929 qsort (&pos
, 3, sizeof (struct fix_24k_store_info
), fix_24k_sort
);
3931 /* Pick a value of ALIGN and X such that all offsets are adjusted by
3932 X bytes and such that the base register + X is known to be aligned
3935 if (((insn
->insn_opcode
>> OP_SH_RS
) & OP_MASK_RS
) == SP
)
3939 align
= pos
[0].align_to
;
3940 base_offset
= pos
[0].off
;
3941 for (i
= 1; i
< 3; i
++)
3942 if (align
< pos
[i
].align_to
)
3944 align
= pos
[i
].align_to
;
3945 base_offset
= pos
[i
].off
;
3947 for (i
= 0; i
< 3; i
++)
3948 pos
[i
].off
-= base_offset
;
3951 pos
[0].off
&= ~align
+ 1;
3952 pos
[1].off
&= ~align
+ 1;
3953 pos
[2].off
&= ~align
+ 1;
3955 /* If any two stores write to the same chunk, they also write to the
3956 same doubleword. The offsets are still sorted at this point. */
3957 if (pos
[0].off
== pos
[1].off
|| pos
[1].off
== pos
[2].off
)
3960 /* A range of at least 9 bytes is needed for the stores to be in
3961 non-overlapping doublewords. */
3962 if (pos
[2].off
- pos
[0].off
<= 8)
3965 if (pos
[2].off
- pos
[1].off
>= 24
3966 || pos
[1].off
- pos
[0].off
>= 24
3967 || pos
[2].off
- pos
[0].off
>= 32)
3973 /* Return the number of nops that would be needed if instruction INSN
3974 immediately followed the MAX_NOPS instructions given by HIST,
3975 where HIST[0] is the most recent instruction. Ignore hazards
3976 between INSN and the first IGNORE instructions in HIST.
3978 If INSN is null, return the worse-case number of nops for any
3982 nops_for_insn (int ignore
, const struct mips_cl_insn
*hist
,
3983 const struct mips_cl_insn
*insn
)
3985 int i
, nops
, tmp_nops
;
3988 for (i
= ignore
; i
< MAX_DELAY_NOPS
; i
++)
3990 tmp_nops
= insns_between (hist
+ i
, insn
) - i
;
3991 if (tmp_nops
> nops
)
3995 if (mips_fix_vr4130
&& !mips_opts
.micromips
)
3997 tmp_nops
= nops_for_vr4130 (ignore
, hist
, insn
);
3998 if (tmp_nops
> nops
)
4002 if (mips_fix_24k
&& !mips_opts
.micromips
)
4004 tmp_nops
= nops_for_24k (ignore
, hist
, insn
);
4005 if (tmp_nops
> nops
)
4012 /* The variable arguments provide NUM_INSNS extra instructions that
4013 might be added to HIST. Return the largest number of nops that
4014 would be needed after the extended sequence, ignoring hazards
4015 in the first IGNORE instructions. */
4018 nops_for_sequence (int num_insns
, int ignore
,
4019 const struct mips_cl_insn
*hist
, ...)
4022 struct mips_cl_insn buffer
[MAX_NOPS
];
4023 struct mips_cl_insn
*cursor
;
4026 va_start (args
, hist
);
4027 cursor
= buffer
+ num_insns
;
4028 memcpy (cursor
, hist
, (MAX_NOPS
- num_insns
) * sizeof (*cursor
));
4029 while (cursor
> buffer
)
4030 *--cursor
= *va_arg (args
, const struct mips_cl_insn
*);
4032 nops
= nops_for_insn (ignore
, buffer
, NULL
);
4037 /* Like nops_for_insn, but if INSN is a branch, take into account the
4038 worst-case delay for the branch target. */
4041 nops_for_insn_or_target (int ignore
, const struct mips_cl_insn
*hist
,
4042 const struct mips_cl_insn
*insn
)
4046 nops
= nops_for_insn (ignore
, hist
, insn
);
4047 if (delayed_branch_p (insn
))
4049 tmp_nops
= nops_for_sequence (2, ignore
? ignore
+ 2 : 0,
4050 hist
, insn
, get_delay_slot_nop (insn
));
4051 if (tmp_nops
> nops
)
4054 else if (compact_branch_p (insn
))
4056 tmp_nops
= nops_for_sequence (1, ignore
? ignore
+ 1 : 0, hist
, insn
);
4057 if (tmp_nops
> nops
)
4063 /* Fix NOP issue: Replace nops by "or at,at,zero". */
4066 fix_loongson2f_nop (struct mips_cl_insn
* ip
)
4068 gas_assert (!HAVE_CODE_COMPRESSION
);
4069 if (strcmp (ip
->insn_mo
->name
, "nop") == 0)
4070 ip
->insn_opcode
= LOONGSON2F_NOP_INSN
;
4073 /* Fix Jump Issue: Eliminate instruction fetch from outside 256M region
4074 jr target pc &= 'hffff_ffff_cfff_ffff. */
4077 fix_loongson2f_jump (struct mips_cl_insn
* ip
)
4079 gas_assert (!HAVE_CODE_COMPRESSION
);
4080 if (strcmp (ip
->insn_mo
->name
, "j") == 0
4081 || strcmp (ip
->insn_mo
->name
, "jr") == 0
4082 || strcmp (ip
->insn_mo
->name
, "jalr") == 0)
4090 sreg
= EXTRACT_OPERAND (0, RS
, *ip
);
4091 if (sreg
== ZERO
|| sreg
== KT0
|| sreg
== KT1
|| sreg
== ATREG
)
4094 ep
.X_op
= O_constant
;
4095 ep
.X_add_number
= 0xcfff0000;
4096 macro_build (&ep
, "lui", "t,u", ATREG
, BFD_RELOC_HI16
);
4097 ep
.X_add_number
= 0xffff;
4098 macro_build (&ep
, "ori", "t,r,i", ATREG
, ATREG
, BFD_RELOC_LO16
);
4099 macro_build (NULL
, "and", "d,v,t", sreg
, sreg
, ATREG
);
4104 fix_loongson2f (struct mips_cl_insn
* ip
)
4106 if (mips_fix_loongson2f_nop
)
4107 fix_loongson2f_nop (ip
);
4109 if (mips_fix_loongson2f_jump
)
4110 fix_loongson2f_jump (ip
);
4113 /* IP is a branch that has a delay slot, and we need to fill it
4114 automatically. Return true if we can do that by swapping IP
4115 with the previous instruction.
4116 ADDRESS_EXPR is an operand of the instruction to be used with
4120 can_swap_branch_p (struct mips_cl_insn
*ip
, expressionS
*address_expr
,
4121 bfd_reloc_code_real_type
*reloc_type
)
4123 unsigned long pinfo
, pinfo2
, prev_pinfo
, prev_pinfo2
;
4124 unsigned int gpr_read
, gpr_write
, prev_gpr_read
, prev_gpr_write
;
4126 /* -O2 and above is required for this optimization. */
4127 if (mips_optimize
< 2)
4130 /* If we have seen .set volatile or .set nomove, don't optimize. */
4131 if (mips_opts
.nomove
)
4134 /* We can't swap if the previous instruction's position is fixed. */
4135 if (history
[0].fixed_p
)
4138 /* If the previous previous insn was in a .set noreorder, we can't
4139 swap. Actually, the MIPS assembler will swap in this situation.
4140 However, gcc configured -with-gnu-as will generate code like
4148 in which we can not swap the bne and INSN. If gcc is not configured
4149 -with-gnu-as, it does not output the .set pseudo-ops. */
4150 if (history
[1].noreorder_p
)
4153 /* If the previous instruction had a fixup in mips16 mode, we can not swap.
4154 This means that the previous instruction was a 4-byte one anyhow. */
4155 if (mips_opts
.mips16
&& history
[0].fixp
[0])
4158 /* If the branch is itself the target of a branch, we can not swap.
4159 We cheat on this; all we check for is whether there is a label on
4160 this instruction. If there are any branches to anything other than
4161 a label, users must use .set noreorder. */
4162 if (seg_info (now_seg
)->label_list
)
4165 /* If the previous instruction is in a variant frag other than this
4166 branch's one, we cannot do the swap. This does not apply to
4167 MIPS16 code, which uses variant frags for different purposes. */
4168 if (!mips_opts
.mips16
4170 && history
[0].frag
->fr_type
== rs_machine_dependent
)
4173 /* We do not swap with instructions that cannot architecturally
4174 be placed in a branch delay slot, such as SYNC or ERET. We
4175 also refrain from swapping with a trap instruction, since it
4176 complicates trap handlers to have the trap instruction be in
4178 prev_pinfo
= history
[0].insn_mo
->pinfo
;
4179 if (prev_pinfo
& INSN_NO_DELAY_SLOT
)
4182 /* Check for conflicts between the branch and the instructions
4183 before the candidate delay slot. */
4184 if (nops_for_insn (0, history
+ 1, ip
) > 0)
4187 /* Check for conflicts between the swapped sequence and the
4188 target of the branch. */
4189 if (nops_for_sequence (2, 0, history
+ 1, ip
, history
) > 0)
4192 /* If the branch reads a register that the previous
4193 instruction sets, we can not swap. */
4194 gpr_read
= gpr_read_mask (ip
);
4195 prev_gpr_write
= gpr_write_mask (&history
[0]);
4196 if (gpr_read
& prev_gpr_write
)
4199 /* If the branch writes a register that the previous
4200 instruction sets, we can not swap. */
4201 gpr_write
= gpr_write_mask (ip
);
4202 if (gpr_write
& prev_gpr_write
)
4205 /* If the branch writes a register that the previous
4206 instruction reads, we can not swap. */
4207 prev_gpr_read
= gpr_read_mask (&history
[0]);
4208 if (gpr_write
& prev_gpr_read
)
4211 /* If one instruction sets a condition code and the
4212 other one uses a condition code, we can not swap. */
4213 pinfo
= ip
->insn_mo
->pinfo
;
4214 if ((pinfo
& INSN_READ_COND_CODE
)
4215 && (prev_pinfo
& INSN_WRITE_COND_CODE
))
4217 if ((pinfo
& INSN_WRITE_COND_CODE
)
4218 && (prev_pinfo
& INSN_READ_COND_CODE
))
4221 /* If the previous instruction uses the PC, we can not swap. */
4222 prev_pinfo2
= history
[0].insn_mo
->pinfo2
;
4223 if (mips_opts
.mips16
&& (prev_pinfo
& MIPS16_INSN_READ_PC
))
4225 if (mips_opts
.micromips
&& (prev_pinfo2
& INSN2_READ_PC
))
4228 /* If the previous instruction has an incorrect size for a fixed
4229 branch delay slot in microMIPS mode, we cannot swap. */
4230 pinfo2
= ip
->insn_mo
->pinfo2
;
4231 if (mips_opts
.micromips
4232 && (pinfo2
& INSN2_BRANCH_DELAY_16BIT
)
4233 && insn_length (history
) != 2)
4235 if (mips_opts
.micromips
4236 && (pinfo2
& INSN2_BRANCH_DELAY_32BIT
)
4237 && insn_length (history
) != 4)
4240 /* On R5900 short loops need to be fixed by inserting a nop in
4241 the branch delay slots.
4242 A short loop can be terminated too early. */
4243 if (mips_opts
.arch
== CPU_R5900
4244 /* Check if instruction has a parameter, ignore "j $31". */
4245 && (address_expr
!= NULL
)
4246 /* Parameter must be 16 bit. */
4247 && (*reloc_type
== BFD_RELOC_16_PCREL_S2
)
4248 /* Branch to same segment. */
4249 && (S_GET_SEGMENT(address_expr
->X_add_symbol
) == now_seg
)
4250 /* Branch to same code fragment. */
4251 && (symbol_get_frag(address_expr
->X_add_symbol
) == frag_now
)
4252 /* Can only calculate branch offset if value is known. */
4253 && symbol_constant_p(address_expr
->X_add_symbol
)
4254 /* Check if branch is really conditional. */
4255 && !((ip
->insn_opcode
& 0xffff0000) == 0x10000000 /* beq $0,$0 */
4256 || (ip
->insn_opcode
& 0xffff0000) == 0x04010000 /* bgez $0 */
4257 || (ip
->insn_opcode
& 0xffff0000) == 0x04110000)) /* bgezal $0 */
4260 /* Check if loop is shorter than 6 instructions including
4261 branch and delay slot. */
4262 distance
= frag_now_fix() - S_GET_VALUE(address_expr
->X_add_symbol
);
4269 /* When the loop includes branches or jumps,
4270 it is not a short loop. */
4271 for (i
= 0; i
< (distance
/ 4); i
++)
4273 if ((history
[i
].cleared_p
)
4274 || delayed_branch_p(&history
[i
]))
4282 /* Insert nop after branch to fix short loop. */
4291 /* Decide how we should add IP to the instruction stream.
4292 ADDRESS_EXPR is an operand of the instruction to be used with
4295 static enum append_method
4296 get_append_method (struct mips_cl_insn
*ip
, expressionS
*address_expr
,
4297 bfd_reloc_code_real_type
*reloc_type
)
4299 unsigned long pinfo
;
4301 /* The relaxed version of a macro sequence must be inherently
4303 if (mips_relax
.sequence
== 2)
4306 /* We must not dabble with instructions in a ".set norerorder" block. */
4307 if (mips_opts
.noreorder
)
4310 /* Otherwise, it's our responsibility to fill branch delay slots. */
4311 if (delayed_branch_p (ip
))
4313 if (!branch_likely_p (ip
)
4314 && can_swap_branch_p (ip
, address_expr
, reloc_type
))
4317 pinfo
= ip
->insn_mo
->pinfo
;
4318 if (mips_opts
.mips16
4319 && ISA_SUPPORTS_MIPS16E
4320 && (pinfo
& (MIPS16_INSN_READ_X
| MIPS16_INSN_READ_31
)))
4321 return APPEND_ADD_COMPACT
;
4323 return APPEND_ADD_WITH_NOP
;
4329 /* IP is a MIPS16 instruction whose opcode we have just changed.
4330 Point IP->insn_mo to the new opcode's definition. */
4333 find_altered_mips16_opcode (struct mips_cl_insn
*ip
)
4335 const struct mips_opcode
*mo
, *end
;
4337 end
= &mips16_opcodes
[bfd_mips16_num_opcodes
];
4338 for (mo
= ip
->insn_mo
; mo
< end
; mo
++)
4339 if ((ip
->insn_opcode
& mo
->mask
) == mo
->match
)
4347 /* For microMIPS macros, we need to generate a local number label
4348 as the target of branches. */
4349 #define MICROMIPS_LABEL_CHAR '\037'
4350 static unsigned long micromips_target_label
;
4351 static char micromips_target_name
[32];
4354 micromips_label_name (void)
4356 char *p
= micromips_target_name
;
4357 char symbol_name_temporary
[24];
4365 l
= micromips_target_label
;
4366 #ifdef LOCAL_LABEL_PREFIX
4367 *p
++ = LOCAL_LABEL_PREFIX
;
4370 *p
++ = MICROMIPS_LABEL_CHAR
;
4373 symbol_name_temporary
[i
++] = l
% 10 + '0';
4378 *p
++ = symbol_name_temporary
[--i
];
4381 return micromips_target_name
;
4385 micromips_label_expr (expressionS
*label_expr
)
4387 label_expr
->X_op
= O_symbol
;
4388 label_expr
->X_add_symbol
= symbol_find_or_make (micromips_label_name ());
4389 label_expr
->X_add_number
= 0;
4393 micromips_label_inc (void)
4395 micromips_target_label
++;
4396 *micromips_target_name
= '\0';
4400 micromips_add_label (void)
4404 s
= colon (micromips_label_name ());
4405 micromips_label_inc ();
4406 S_SET_OTHER (s
, ELF_ST_SET_MICROMIPS (S_GET_OTHER (s
)));
4409 /* If assembling microMIPS code, then return the microMIPS reloc
4410 corresponding to the requested one if any. Otherwise return
4411 the reloc unchanged. */
4413 static bfd_reloc_code_real_type
4414 micromips_map_reloc (bfd_reloc_code_real_type reloc
)
4416 static const bfd_reloc_code_real_type relocs
[][2] =
4418 /* Keep sorted incrementally by the left-hand key. */
4419 { BFD_RELOC_16_PCREL_S2
, BFD_RELOC_MICROMIPS_16_PCREL_S1
},
4420 { BFD_RELOC_GPREL16
, BFD_RELOC_MICROMIPS_GPREL16
},
4421 { BFD_RELOC_MIPS_JMP
, BFD_RELOC_MICROMIPS_JMP
},
4422 { BFD_RELOC_HI16
, BFD_RELOC_MICROMIPS_HI16
},
4423 { BFD_RELOC_HI16_S
, BFD_RELOC_MICROMIPS_HI16_S
},
4424 { BFD_RELOC_LO16
, BFD_RELOC_MICROMIPS_LO16
},
4425 { BFD_RELOC_MIPS_LITERAL
, BFD_RELOC_MICROMIPS_LITERAL
},
4426 { BFD_RELOC_MIPS_GOT16
, BFD_RELOC_MICROMIPS_GOT16
},
4427 { BFD_RELOC_MIPS_CALL16
, BFD_RELOC_MICROMIPS_CALL16
},
4428 { BFD_RELOC_MIPS_GOT_HI16
, BFD_RELOC_MICROMIPS_GOT_HI16
},
4429 { BFD_RELOC_MIPS_GOT_LO16
, BFD_RELOC_MICROMIPS_GOT_LO16
},
4430 { BFD_RELOC_MIPS_CALL_HI16
, BFD_RELOC_MICROMIPS_CALL_HI16
},
4431 { BFD_RELOC_MIPS_CALL_LO16
, BFD_RELOC_MICROMIPS_CALL_LO16
},
4432 { BFD_RELOC_MIPS_SUB
, BFD_RELOC_MICROMIPS_SUB
},
4433 { BFD_RELOC_MIPS_GOT_PAGE
, BFD_RELOC_MICROMIPS_GOT_PAGE
},
4434 { BFD_RELOC_MIPS_GOT_OFST
, BFD_RELOC_MICROMIPS_GOT_OFST
},
4435 { BFD_RELOC_MIPS_GOT_DISP
, BFD_RELOC_MICROMIPS_GOT_DISP
},
4436 { BFD_RELOC_MIPS_HIGHEST
, BFD_RELOC_MICROMIPS_HIGHEST
},
4437 { BFD_RELOC_MIPS_HIGHER
, BFD_RELOC_MICROMIPS_HIGHER
},
4438 { BFD_RELOC_MIPS_SCN_DISP
, BFD_RELOC_MICROMIPS_SCN_DISP
},
4439 { BFD_RELOC_MIPS_TLS_GD
, BFD_RELOC_MICROMIPS_TLS_GD
},
4440 { BFD_RELOC_MIPS_TLS_LDM
, BFD_RELOC_MICROMIPS_TLS_LDM
},
4441 { BFD_RELOC_MIPS_TLS_DTPREL_HI16
, BFD_RELOC_MICROMIPS_TLS_DTPREL_HI16
},
4442 { BFD_RELOC_MIPS_TLS_DTPREL_LO16
, BFD_RELOC_MICROMIPS_TLS_DTPREL_LO16
},
4443 { BFD_RELOC_MIPS_TLS_GOTTPREL
, BFD_RELOC_MICROMIPS_TLS_GOTTPREL
},
4444 { BFD_RELOC_MIPS_TLS_TPREL_HI16
, BFD_RELOC_MICROMIPS_TLS_TPREL_HI16
},
4445 { BFD_RELOC_MIPS_TLS_TPREL_LO16
, BFD_RELOC_MICROMIPS_TLS_TPREL_LO16
}
4447 bfd_reloc_code_real_type r
;
4450 if (!mips_opts
.micromips
)
4452 for (i
= 0; i
< ARRAY_SIZE (relocs
); i
++)
4458 return relocs
[i
][1];
4463 /* Try to resolve relocation RELOC against constant OPERAND at assembly time.
4464 Return true on success, storing the resolved value in RESULT. */
4467 calculate_reloc (bfd_reloc_code_real_type reloc
, offsetT operand
,
4472 case BFD_RELOC_MIPS_HIGHEST
:
4473 case BFD_RELOC_MICROMIPS_HIGHEST
:
4474 *result
= ((operand
+ 0x800080008000ull
) >> 48) & 0xffff;
4477 case BFD_RELOC_MIPS_HIGHER
:
4478 case BFD_RELOC_MICROMIPS_HIGHER
:
4479 *result
= ((operand
+ 0x80008000ull
) >> 32) & 0xffff;
4482 case BFD_RELOC_HI16_S
:
4483 case BFD_RELOC_MICROMIPS_HI16_S
:
4484 case BFD_RELOC_MIPS16_HI16_S
:
4485 *result
= ((operand
+ 0x8000) >> 16) & 0xffff;
4488 case BFD_RELOC_HI16
:
4489 case BFD_RELOC_MICROMIPS_HI16
:
4490 case BFD_RELOC_MIPS16_HI16
:
4491 *result
= (operand
>> 16) & 0xffff;
4494 case BFD_RELOC_LO16
:
4495 case BFD_RELOC_MICROMIPS_LO16
:
4496 case BFD_RELOC_MIPS16_LO16
:
4497 *result
= operand
& 0xffff;
4500 case BFD_RELOC_UNUSED
:
4509 /* Output an instruction. IP is the instruction information.
4510 ADDRESS_EXPR is an operand of the instruction to be used with
4511 RELOC_TYPE. EXPANSIONP is true if the instruction is part of
4512 a macro expansion. */
4515 append_insn (struct mips_cl_insn
*ip
, expressionS
*address_expr
,
4516 bfd_reloc_code_real_type
*reloc_type
, bfd_boolean expansionp
)
4518 unsigned long prev_pinfo2
, pinfo
;
4519 bfd_boolean relaxed_branch
= FALSE
;
4520 enum append_method method
;
4521 bfd_boolean relax32
;
4524 if (mips_fix_loongson2f
&& !HAVE_CODE_COMPRESSION
)
4525 fix_loongson2f (ip
);
4527 file_ase_mips16
|= mips_opts
.mips16
;
4528 file_ase_micromips
|= mips_opts
.micromips
;
4530 prev_pinfo2
= history
[0].insn_mo
->pinfo2
;
4531 pinfo
= ip
->insn_mo
->pinfo
;
4533 if (mips_opts
.micromips
4535 && (((prev_pinfo2
& INSN2_BRANCH_DELAY_16BIT
) != 0
4536 && micromips_insn_length (ip
->insn_mo
) != 2)
4537 || ((prev_pinfo2
& INSN2_BRANCH_DELAY_32BIT
) != 0
4538 && micromips_insn_length (ip
->insn_mo
) != 4)))
4539 as_warn (_("Wrong size instruction in a %u-bit branch delay slot"),
4540 (prev_pinfo2
& INSN2_BRANCH_DELAY_16BIT
) != 0 ? 16 : 32);
4542 if (address_expr
== NULL
)
4544 else if (reloc_type
[0] <= BFD_RELOC_UNUSED
4545 && reloc_type
[1] == BFD_RELOC_UNUSED
4546 && reloc_type
[2] == BFD_RELOC_UNUSED
4547 && address_expr
->X_op
== O_constant
)
4549 switch (*reloc_type
)
4551 case BFD_RELOC_MIPS_JMP
:
4555 shift
= mips_opts
.micromips
? 1 : 2;
4556 if ((address_expr
->X_add_number
& ((1 << shift
) - 1)) != 0)
4557 as_bad (_("jump to misaligned address (0x%lx)"),
4558 (unsigned long) address_expr
->X_add_number
);
4559 ip
->insn_opcode
|= ((address_expr
->X_add_number
>> shift
)
4565 case BFD_RELOC_MIPS16_JMP
:
4566 if ((address_expr
->X_add_number
& 3) != 0)
4567 as_bad (_("jump to misaligned address (0x%lx)"),
4568 (unsigned long) address_expr
->X_add_number
);
4570 (((address_expr
->X_add_number
& 0x7c0000) << 3)
4571 | ((address_expr
->X_add_number
& 0xf800000) >> 7)
4572 | ((address_expr
->X_add_number
& 0x3fffc) >> 2));
4576 case BFD_RELOC_16_PCREL_S2
:
4580 shift
= mips_opts
.micromips
? 1 : 2;
4581 if ((address_expr
->X_add_number
& ((1 << shift
) - 1)) != 0)
4582 as_bad (_("branch to misaligned address (0x%lx)"),
4583 (unsigned long) address_expr
->X_add_number
);
4584 if (!mips_relax_branch
)
4586 if ((address_expr
->X_add_number
+ (1 << (shift
+ 15)))
4587 & ~((1 << (shift
+ 16)) - 1))
4588 as_bad (_("branch address range overflow (0x%lx)"),
4589 (unsigned long) address_expr
->X_add_number
);
4590 ip
->insn_opcode
|= ((address_expr
->X_add_number
>> shift
)
4600 if (calculate_reloc (*reloc_type
, address_expr
->X_add_number
,
4603 ip
->insn_opcode
|= value
& 0xffff;
4611 if (mips_relax
.sequence
!= 2 && !mips_opts
.noreorder
)
4613 /* There are a lot of optimizations we could do that we don't.
4614 In particular, we do not, in general, reorder instructions.
4615 If you use gcc with optimization, it will reorder
4616 instructions and generally do much more optimization then we
4617 do here; repeating all that work in the assembler would only
4618 benefit hand written assembly code, and does not seem worth
4620 int nops
= (mips_optimize
== 0
4621 ? nops_for_insn (0, history
, NULL
)
4622 : nops_for_insn_or_target (0, history
, ip
));
4626 unsigned long old_frag_offset
;
4629 old_frag
= frag_now
;
4630 old_frag_offset
= frag_now_fix ();
4632 for (i
= 0; i
< nops
; i
++)
4633 add_fixed_insn (NOP_INSN
);
4634 insert_into_history (0, nops
, NOP_INSN
);
4638 listing_prev_line ();
4639 /* We may be at the start of a variant frag. In case we
4640 are, make sure there is enough space for the frag
4641 after the frags created by listing_prev_line. The
4642 argument to frag_grow here must be at least as large
4643 as the argument to all other calls to frag_grow in
4644 this file. We don't have to worry about being in the
4645 middle of a variant frag, because the variants insert
4646 all needed nop instructions themselves. */
4650 mips_move_text_labels ();
4652 #ifndef NO_ECOFF_DEBUGGING
4653 if (ECOFF_DEBUGGING
)
4654 ecoff_fix_loc (old_frag
, old_frag_offset
);
4658 else if (mips_relax
.sequence
!= 2 && prev_nop_frag
!= NULL
)
4662 /* Work out how many nops in prev_nop_frag are needed by IP,
4663 ignoring hazards generated by the first prev_nop_frag_since
4665 nops
= nops_for_insn_or_target (prev_nop_frag_since
, history
, ip
);
4666 gas_assert (nops
<= prev_nop_frag_holds
);
4668 /* Enforce NOPS as a minimum. */
4669 if (nops
> prev_nop_frag_required
)
4670 prev_nop_frag_required
= nops
;
4672 if (prev_nop_frag_holds
== prev_nop_frag_required
)
4674 /* Settle for the current number of nops. Update the history
4675 accordingly (for the benefit of any future .set reorder code). */
4676 prev_nop_frag
= NULL
;
4677 insert_into_history (prev_nop_frag_since
,
4678 prev_nop_frag_holds
, NOP_INSN
);
4682 /* Allow this instruction to replace one of the nops that was
4683 tentatively added to prev_nop_frag. */
4684 prev_nop_frag
->fr_fix
-= NOP_INSN_SIZE
;
4685 prev_nop_frag_holds
--;
4686 prev_nop_frag_since
++;
4690 method
= get_append_method (ip
, address_expr
, reloc_type
);
4691 branch_disp
= method
== APPEND_SWAP
? insn_length (history
) : 0;
4693 dwarf2_emit_insn (0);
4694 /* We want MIPS16 and microMIPS debug info to use ISA-encoded addresses,
4695 so "move" the instruction address accordingly.
4697 Also, it doesn't seem appropriate for the assembler to reorder .loc
4698 entries. If this instruction is a branch that we are going to swap
4699 with the previous instruction, the two instructions should be
4700 treated as a unit, and the debug information for both instructions
4701 should refer to the start of the branch sequence. Using the
4702 current position is certainly wrong when swapping a 32-bit branch
4703 and a 16-bit delay slot, since the current position would then be
4704 in the middle of a branch. */
4705 dwarf2_move_insn ((HAVE_CODE_COMPRESSION
? 1 : 0) - branch_disp
);
4707 relax32
= (mips_relax_branch
4708 /* Don't try branch relaxation within .set nomacro, or within
4709 .set noat if we use $at for PIC computations. If it turns
4710 out that the branch was out-of-range, we'll get an error. */
4711 && !mips_opts
.warn_about_macros
4712 && (mips_opts
.at
|| mips_pic
== NO_PIC
)
4713 /* Don't relax BPOSGE32/64 or BC1ANY2T/F and BC1ANY4T/F
4714 as they have no complementing branches. */
4715 && !(ip
->insn_mo
->ase
& (ASE_MIPS3D
| ASE_DSP64
| ASE_DSP
)));
4717 if (!HAVE_CODE_COMPRESSION
4720 && *reloc_type
== BFD_RELOC_16_PCREL_S2
4721 && delayed_branch_p (ip
))
4723 relaxed_branch
= TRUE
;
4724 add_relaxed_insn (ip
, (relaxed_branch_length
4726 uncond_branch_p (ip
) ? -1
4727 : branch_likely_p (ip
) ? 1
4731 uncond_branch_p (ip
),
4732 branch_likely_p (ip
),
4733 pinfo
& INSN_WRITE_GPR_31
,
4735 address_expr
->X_add_symbol
,
4736 address_expr
->X_add_number
);
4737 *reloc_type
= BFD_RELOC_UNUSED
;
4739 else if (mips_opts
.micromips
4741 && ((relax32
&& *reloc_type
== BFD_RELOC_16_PCREL_S2
)
4742 || *reloc_type
> BFD_RELOC_UNUSED
)
4743 && (delayed_branch_p (ip
) || compact_branch_p (ip
))
4744 /* Don't try branch relaxation when users specify
4745 16-bit/32-bit instructions. */
4746 && !forced_insn_length
)
4748 bfd_boolean relax16
= *reloc_type
> BFD_RELOC_UNUSED
;
4749 int type
= relax16
? *reloc_type
- BFD_RELOC_UNUSED
: 0;
4750 int uncond
= uncond_branch_p (ip
) ? -1 : 0;
4751 int compact
= compact_branch_p (ip
);
4752 int al
= pinfo
& INSN_WRITE_GPR_31
;
4755 gas_assert (address_expr
!= NULL
);
4756 gas_assert (!mips_relax
.sequence
);
4758 relaxed_branch
= TRUE
;
4759 length32
= relaxed_micromips_32bit_branch_length (NULL
, NULL
, uncond
);
4760 add_relaxed_insn (ip
, relax32
? length32
: 4, relax16
? 2 : 4,
4761 RELAX_MICROMIPS_ENCODE (type
, AT
, uncond
, compact
, al
,
4763 address_expr
->X_add_symbol
,
4764 address_expr
->X_add_number
);
4765 *reloc_type
= BFD_RELOC_UNUSED
;
4767 else if (mips_opts
.mips16
&& *reloc_type
> BFD_RELOC_UNUSED
)
4769 /* We need to set up a variant frag. */
4770 gas_assert (address_expr
!= NULL
);
4771 add_relaxed_insn (ip
, 4, 0,
4773 (*reloc_type
- BFD_RELOC_UNUSED
,
4774 forced_insn_length
== 2, forced_insn_length
== 4,
4775 delayed_branch_p (&history
[0]),
4776 history
[0].mips16_absolute_jump_p
),
4777 make_expr_symbol (address_expr
), 0);
4779 else if (mips_opts
.mips16
&& insn_length (ip
) == 2)
4781 if (!delayed_branch_p (ip
))
4782 /* Make sure there is enough room to swap this instruction with
4783 a following jump instruction. */
4785 add_fixed_insn (ip
);
4789 if (mips_opts
.mips16
4790 && mips_opts
.noreorder
4791 && delayed_branch_p (&history
[0]))
4792 as_warn (_("extended instruction in delay slot"));
4794 if (mips_relax
.sequence
)
4796 /* If we've reached the end of this frag, turn it into a variant
4797 frag and record the information for the instructions we've
4799 if (frag_room () < 4)
4800 relax_close_frag ();
4801 mips_relax
.sizes
[mips_relax
.sequence
- 1] += insn_length (ip
);
4804 if (mips_relax
.sequence
!= 2)
4806 if (mips_macro_warning
.first_insn_sizes
[0] == 0)
4807 mips_macro_warning
.first_insn_sizes
[0] = insn_length (ip
);
4808 mips_macro_warning
.sizes
[0] += insn_length (ip
);
4809 mips_macro_warning
.insns
[0]++;
4811 if (mips_relax
.sequence
!= 1)
4813 if (mips_macro_warning
.first_insn_sizes
[1] == 0)
4814 mips_macro_warning
.first_insn_sizes
[1] = insn_length (ip
);
4815 mips_macro_warning
.sizes
[1] += insn_length (ip
);
4816 mips_macro_warning
.insns
[1]++;
4819 if (mips_opts
.mips16
)
4822 ip
->mips16_absolute_jump_p
= (*reloc_type
== BFD_RELOC_MIPS16_JMP
);
4824 add_fixed_insn (ip
);
4827 if (!ip
->complete_p
&& *reloc_type
< BFD_RELOC_UNUSED
)
4829 bfd_reloc_code_real_type final_type
[3];
4830 reloc_howto_type
*howto0
;
4831 reloc_howto_type
*howto
;
4834 /* Perform any necessary conversion to microMIPS relocations
4835 and find out how many relocations there actually are. */
4836 for (i
= 0; i
< 3 && reloc_type
[i
] != BFD_RELOC_UNUSED
; i
++)
4837 final_type
[i
] = micromips_map_reloc (reloc_type
[i
]);
4839 /* In a compound relocation, it is the final (outermost)
4840 operator that determines the relocated field. */
4841 howto
= howto0
= bfd_reloc_type_lookup (stdoutput
, final_type
[i
- 1]);
4846 howto0
= bfd_reloc_type_lookup (stdoutput
, final_type
[0]);
4847 ip
->fixp
[0] = fix_new_exp (ip
->frag
, ip
->where
,
4848 bfd_get_reloc_size (howto
),
4850 howto0
&& howto0
->pc_relative
,
4853 /* Tag symbols that have a R_MIPS16_26 relocation against them. */
4854 if (final_type
[0] == BFD_RELOC_MIPS16_JMP
&& ip
->fixp
[0]->fx_addsy
)
4855 *symbol_get_tc (ip
->fixp
[0]->fx_addsy
) = 1;
4857 /* These relocations can have an addend that won't fit in
4858 4 octets for 64bit assembly. */
4860 && ! howto
->partial_inplace
4861 && (reloc_type
[0] == BFD_RELOC_16
4862 || reloc_type
[0] == BFD_RELOC_32
4863 || reloc_type
[0] == BFD_RELOC_MIPS_JMP
4864 || reloc_type
[0] == BFD_RELOC_GPREL16
4865 || reloc_type
[0] == BFD_RELOC_MIPS_LITERAL
4866 || reloc_type
[0] == BFD_RELOC_GPREL32
4867 || reloc_type
[0] == BFD_RELOC_64
4868 || reloc_type
[0] == BFD_RELOC_CTOR
4869 || reloc_type
[0] == BFD_RELOC_MIPS_SUB
4870 || reloc_type
[0] == BFD_RELOC_MIPS_HIGHEST
4871 || reloc_type
[0] == BFD_RELOC_MIPS_HIGHER
4872 || reloc_type
[0] == BFD_RELOC_MIPS_SCN_DISP
4873 || reloc_type
[0] == BFD_RELOC_MIPS_REL16
4874 || reloc_type
[0] == BFD_RELOC_MIPS_RELGOT
4875 || reloc_type
[0] == BFD_RELOC_MIPS16_GPREL
4876 || hi16_reloc_p (reloc_type
[0])
4877 || lo16_reloc_p (reloc_type
[0])))
4878 ip
->fixp
[0]->fx_no_overflow
= 1;
4880 /* These relocations can have an addend that won't fit in 2 octets. */
4881 if (reloc_type
[0] == BFD_RELOC_MICROMIPS_7_PCREL_S1
4882 || reloc_type
[0] == BFD_RELOC_MICROMIPS_10_PCREL_S1
)
4883 ip
->fixp
[0]->fx_no_overflow
= 1;
4885 if (mips_relax
.sequence
)
4887 if (mips_relax
.first_fixup
== 0)
4888 mips_relax
.first_fixup
= ip
->fixp
[0];
4890 else if (reloc_needs_lo_p (*reloc_type
))
4892 struct mips_hi_fixup
*hi_fixup
;
4894 /* Reuse the last entry if it already has a matching %lo. */
4895 hi_fixup
= mips_hi_fixup_list
;
4897 || !fixup_has_matching_lo_p (hi_fixup
->fixp
))
4899 hi_fixup
= ((struct mips_hi_fixup
*)
4900 xmalloc (sizeof (struct mips_hi_fixup
)));
4901 hi_fixup
->next
= mips_hi_fixup_list
;
4902 mips_hi_fixup_list
= hi_fixup
;
4904 hi_fixup
->fixp
= ip
->fixp
[0];
4905 hi_fixup
->seg
= now_seg
;
4908 /* Add fixups for the second and third relocations, if given.
4909 Note that the ABI allows the second relocation to be
4910 against RSS_UNDEF, RSS_GP, RSS_GP0 or RSS_LOC. At the
4911 moment we only use RSS_UNDEF, but we could add support
4912 for the others if it ever becomes necessary. */
4913 for (i
= 1; i
< 3; i
++)
4914 if (reloc_type
[i
] != BFD_RELOC_UNUSED
)
4916 ip
->fixp
[i
] = fix_new (ip
->frag
, ip
->where
,
4917 ip
->fixp
[0]->fx_size
, NULL
, 0,
4918 FALSE
, final_type
[i
]);
4920 /* Use fx_tcbit to mark compound relocs. */
4921 ip
->fixp
[0]->fx_tcbit
= 1;
4922 ip
->fixp
[i
]->fx_tcbit
= 1;
4927 /* Update the register mask information. */
4928 mips_gprmask
|= gpr_read_mask (ip
) | gpr_write_mask (ip
);
4929 mips_cprmask
[1] |= fpr_read_mask (ip
) | fpr_write_mask (ip
);
4934 insert_into_history (0, 1, ip
);
4937 case APPEND_ADD_WITH_NOP
:
4939 struct mips_cl_insn
*nop
;
4941 insert_into_history (0, 1, ip
);
4942 nop
= get_delay_slot_nop (ip
);
4943 add_fixed_insn (nop
);
4944 insert_into_history (0, 1, nop
);
4945 if (mips_relax
.sequence
)
4946 mips_relax
.sizes
[mips_relax
.sequence
- 1] += insn_length (nop
);
4950 case APPEND_ADD_COMPACT
:
4951 /* Convert MIPS16 jr/jalr into a "compact" jump. */
4952 gas_assert (mips_opts
.mips16
);
4953 ip
->insn_opcode
|= 0x0080;
4954 find_altered_mips16_opcode (ip
);
4956 insert_into_history (0, 1, ip
);
4961 struct mips_cl_insn delay
= history
[0];
4962 if (mips_opts
.mips16
)
4964 know (delay
.frag
== ip
->frag
);
4965 move_insn (ip
, delay
.frag
, delay
.where
);
4966 move_insn (&delay
, ip
->frag
, ip
->where
+ insn_length (ip
));
4968 else if (relaxed_branch
|| delay
.frag
!= ip
->frag
)
4970 /* Add the delay slot instruction to the end of the
4971 current frag and shrink the fixed part of the
4972 original frag. If the branch occupies the tail of
4973 the latter, move it backwards to cover the gap. */
4974 delay
.frag
->fr_fix
-= branch_disp
;
4975 if (delay
.frag
== ip
->frag
)
4976 move_insn (ip
, ip
->frag
, ip
->where
- branch_disp
);
4977 add_fixed_insn (&delay
);
4981 move_insn (&delay
, ip
->frag
,
4982 ip
->where
- branch_disp
+ insn_length (ip
));
4983 move_insn (ip
, history
[0].frag
, history
[0].where
);
4987 insert_into_history (0, 1, &delay
);
4992 /* If we have just completed an unconditional branch, clear the history. */
4993 if ((delayed_branch_p (&history
[1]) && uncond_branch_p (&history
[1]))
4994 || (compact_branch_p (&history
[0]) && uncond_branch_p (&history
[0])))
4998 mips_no_prev_insn ();
5000 for (i
= 0; i
< ARRAY_SIZE (history
); i
++)
5001 history
[i
].cleared_p
= 1;
5004 /* We need to emit a label at the end of branch-likely macros. */
5005 if (emit_branch_likely_macro
)
5007 emit_branch_likely_macro
= FALSE
;
5008 micromips_add_label ();
5011 /* We just output an insn, so the next one doesn't have a label. */
5012 mips_clear_insn_labels ();
5015 /* Forget that there was any previous instruction or label.
5016 When BRANCH is true, the branch history is also flushed. */
5019 mips_no_prev_insn (void)
5021 prev_nop_frag
= NULL
;
5022 insert_into_history (0, ARRAY_SIZE (history
), NOP_INSN
);
5023 mips_clear_insn_labels ();
5026 /* This function must be called before we emit something other than
5027 instructions. It is like mips_no_prev_insn except that it inserts
5028 any NOPS that might be needed by previous instructions. */
5031 mips_emit_delays (void)
5033 if (! mips_opts
.noreorder
)
5035 int nops
= nops_for_insn (0, history
, NULL
);
5039 add_fixed_insn (NOP_INSN
);
5040 mips_move_text_labels ();
5043 mips_no_prev_insn ();
5046 /* Start a (possibly nested) noreorder block. */
5049 start_noreorder (void)
5051 if (mips_opts
.noreorder
== 0)
5056 /* None of the instructions before the .set noreorder can be moved. */
5057 for (i
= 0; i
< ARRAY_SIZE (history
); i
++)
5058 history
[i
].fixed_p
= 1;
5060 /* Insert any nops that might be needed between the .set noreorder
5061 block and the previous instructions. We will later remove any
5062 nops that turn out not to be needed. */
5063 nops
= nops_for_insn (0, history
, NULL
);
5066 if (mips_optimize
!= 0)
5068 /* Record the frag which holds the nop instructions, so
5069 that we can remove them if we don't need them. */
5070 frag_grow (nops
* NOP_INSN_SIZE
);
5071 prev_nop_frag
= frag_now
;
5072 prev_nop_frag_holds
= nops
;
5073 prev_nop_frag_required
= 0;
5074 prev_nop_frag_since
= 0;
5077 for (; nops
> 0; --nops
)
5078 add_fixed_insn (NOP_INSN
);
5080 /* Move on to a new frag, so that it is safe to simply
5081 decrease the size of prev_nop_frag. */
5082 frag_wane (frag_now
);
5084 mips_move_text_labels ();
5086 mips_mark_labels ();
5087 mips_clear_insn_labels ();
5089 mips_opts
.noreorder
++;
5090 mips_any_noreorder
= 1;
5093 /* End a nested noreorder block. */
5096 end_noreorder (void)
5098 mips_opts
.noreorder
--;
5099 if (mips_opts
.noreorder
== 0 && prev_nop_frag
!= NULL
)
5101 /* Commit to inserting prev_nop_frag_required nops and go back to
5102 handling nop insertion the .set reorder way. */
5103 prev_nop_frag
->fr_fix
-= ((prev_nop_frag_holds
- prev_nop_frag_required
)
5105 insert_into_history (prev_nop_frag_since
,
5106 prev_nop_frag_required
, NOP_INSN
);
5107 prev_nop_frag
= NULL
;
5111 /* Set up global variables for the start of a new macro. */
5116 memset (&mips_macro_warning
.sizes
, 0, sizeof (mips_macro_warning
.sizes
));
5117 memset (&mips_macro_warning
.first_insn_sizes
, 0,
5118 sizeof (mips_macro_warning
.first_insn_sizes
));
5119 memset (&mips_macro_warning
.insns
, 0, sizeof (mips_macro_warning
.insns
));
5120 mips_macro_warning
.delay_slot_p
= (mips_opts
.noreorder
5121 && delayed_branch_p (&history
[0]));
5122 switch (history
[0].insn_mo
->pinfo2
5123 & (INSN2_BRANCH_DELAY_32BIT
| INSN2_BRANCH_DELAY_16BIT
))
5125 case INSN2_BRANCH_DELAY_32BIT
:
5126 mips_macro_warning
.delay_slot_length
= 4;
5128 case INSN2_BRANCH_DELAY_16BIT
:
5129 mips_macro_warning
.delay_slot_length
= 2;
5132 mips_macro_warning
.delay_slot_length
= 0;
5135 mips_macro_warning
.first_frag
= NULL
;
5138 /* Given that a macro is longer than one instruction or of the wrong size,
5139 return the appropriate warning for it. Return null if no warning is
5140 needed. SUBTYPE is a bitmask of RELAX_DELAY_SLOT, RELAX_DELAY_SLOT_16BIT,
5141 RELAX_DELAY_SLOT_SIZE_FIRST, RELAX_DELAY_SLOT_SIZE_SECOND,
5142 and RELAX_NOMACRO. */
5145 macro_warning (relax_substateT subtype
)
5147 if (subtype
& RELAX_DELAY_SLOT
)
5148 return _("Macro instruction expanded into multiple instructions"
5149 " in a branch delay slot");
5150 else if (subtype
& RELAX_NOMACRO
)
5151 return _("Macro instruction expanded into multiple instructions");
5152 else if (subtype
& (RELAX_DELAY_SLOT_SIZE_FIRST
5153 | RELAX_DELAY_SLOT_SIZE_SECOND
))
5154 return ((subtype
& RELAX_DELAY_SLOT_16BIT
)
5155 ? _("Macro instruction expanded into a wrong size instruction"
5156 " in a 16-bit branch delay slot")
5157 : _("Macro instruction expanded into a wrong size instruction"
5158 " in a 32-bit branch delay slot"));
5163 /* Finish up a macro. Emit warnings as appropriate. */
5168 /* Relaxation warning flags. */
5169 relax_substateT subtype
= 0;
5171 /* Check delay slot size requirements. */
5172 if (mips_macro_warning
.delay_slot_length
== 2)
5173 subtype
|= RELAX_DELAY_SLOT_16BIT
;
5174 if (mips_macro_warning
.delay_slot_length
!= 0)
5176 if (mips_macro_warning
.delay_slot_length
5177 != mips_macro_warning
.first_insn_sizes
[0])
5178 subtype
|= RELAX_DELAY_SLOT_SIZE_FIRST
;
5179 if (mips_macro_warning
.delay_slot_length
5180 != mips_macro_warning
.first_insn_sizes
[1])
5181 subtype
|= RELAX_DELAY_SLOT_SIZE_SECOND
;
5184 /* Check instruction count requirements. */
5185 if (mips_macro_warning
.insns
[0] > 1 || mips_macro_warning
.insns
[1] > 1)
5187 if (mips_macro_warning
.insns
[1] > mips_macro_warning
.insns
[0])
5188 subtype
|= RELAX_SECOND_LONGER
;
5189 if (mips_opts
.warn_about_macros
)
5190 subtype
|= RELAX_NOMACRO
;
5191 if (mips_macro_warning
.delay_slot_p
)
5192 subtype
|= RELAX_DELAY_SLOT
;
5195 /* If both alternatives fail to fill a delay slot correctly,
5196 emit the warning now. */
5197 if ((subtype
& RELAX_DELAY_SLOT_SIZE_FIRST
) != 0
5198 && (subtype
& RELAX_DELAY_SLOT_SIZE_SECOND
) != 0)
5203 s
= subtype
& (RELAX_DELAY_SLOT_16BIT
5204 | RELAX_DELAY_SLOT_SIZE_FIRST
5205 | RELAX_DELAY_SLOT_SIZE_SECOND
);
5206 msg
= macro_warning (s
);
5208 as_warn ("%s", msg
);
5212 /* If both implementations are longer than 1 instruction, then emit the
5214 if (mips_macro_warning
.insns
[0] > 1 && mips_macro_warning
.insns
[1] > 1)
5219 s
= subtype
& (RELAX_SECOND_LONGER
| RELAX_NOMACRO
| RELAX_DELAY_SLOT
);
5220 msg
= macro_warning (s
);
5222 as_warn ("%s", msg
);
5226 /* If any flags still set, then one implementation might need a warning
5227 and the other either will need one of a different kind or none at all.
5228 Pass any remaining flags over to relaxation. */
5229 if (mips_macro_warning
.first_frag
!= NULL
)
5230 mips_macro_warning
.first_frag
->fr_subtype
|= subtype
;
5233 /* Instruction operand formats used in macros that vary between
5234 standard MIPS and microMIPS code. */
5236 static const char * const brk_fmt
[2][2] = { { "c", "c" }, { "mF", "c" } };
5237 static const char * const cop12_fmt
[2] = { "E,o(b)", "E,~(b)" };
5238 static const char * const jalr_fmt
[2] = { "d,s", "t,s" };
5239 static const char * const lui_fmt
[2] = { "t,u", "s,u" };
5240 static const char * const mem12_fmt
[2] = { "t,o(b)", "t,~(b)" };
5241 static const char * const mfhl_fmt
[2][2] = { { "d", "d" }, { "mj", "s" } };
5242 static const char * const shft_fmt
[2] = { "d,w,<", "t,r,<" };
5243 static const char * const trap_fmt
[2] = { "s,t,q", "s,t,|" };
5245 #define BRK_FMT (brk_fmt[mips_opts.micromips][mips_opts.insn32])
5246 #define COP12_FMT (cop12_fmt[mips_opts.micromips])
5247 #define JALR_FMT (jalr_fmt[mips_opts.micromips])
5248 #define LUI_FMT (lui_fmt[mips_opts.micromips])
5249 #define MEM12_FMT (mem12_fmt[mips_opts.micromips])
5250 #define MFHL_FMT (mfhl_fmt[mips_opts.micromips][mips_opts.insn32])
5251 #define SHFT_FMT (shft_fmt[mips_opts.micromips])
5252 #define TRAP_FMT (trap_fmt[mips_opts.micromips])
5254 /* Read a macro's relocation codes from *ARGS and store them in *R.
5255 The first argument in *ARGS will be either the code for a single
5256 relocation or -1 followed by the three codes that make up a
5257 composite relocation. */
5260 macro_read_relocs (va_list *args
, bfd_reloc_code_real_type
*r
)
5264 next
= va_arg (*args
, int);
5266 r
[0] = (bfd_reloc_code_real_type
) next
;
5268 for (i
= 0; i
< 3; i
++)
5269 r
[i
] = (bfd_reloc_code_real_type
) va_arg (*args
, int);
5272 /* Build an instruction created by a macro expansion. This is passed
5273 a pointer to the count of instructions created so far, an
5274 expression, the name of the instruction to build, an operand format
5275 string, and corresponding arguments. */
5278 macro_build (expressionS
*ep
, const char *name
, const char *fmt
, ...)
5280 const struct mips_opcode
*mo
= NULL
;
5281 bfd_reloc_code_real_type r
[3];
5282 const struct mips_opcode
*amo
;
5283 struct hash_control
*hash
;
5284 struct mips_cl_insn insn
;
5287 va_start (args
, fmt
);
5289 if (mips_opts
.mips16
)
5291 mips16_macro_build (ep
, name
, fmt
, &args
);
5296 r
[0] = BFD_RELOC_UNUSED
;
5297 r
[1] = BFD_RELOC_UNUSED
;
5298 r
[2] = BFD_RELOC_UNUSED
;
5299 hash
= mips_opts
.micromips
? micromips_op_hash
: op_hash
;
5300 amo
= (struct mips_opcode
*) hash_find (hash
, name
);
5302 gas_assert (strcmp (name
, amo
->name
) == 0);
5306 /* Search until we get a match for NAME. It is assumed here that
5307 macros will never generate MDMX, MIPS-3D, or MT instructions.
5308 We try to match an instruction that fulfils the branch delay
5309 slot instruction length requirement (if any) of the previous
5310 instruction. While doing this we record the first instruction
5311 seen that matches all the other conditions and use it anyway
5312 if the requirement cannot be met; we will issue an appropriate
5313 warning later on. */
5314 if (strcmp (fmt
, amo
->args
) == 0
5315 && amo
->pinfo
!= INSN_MACRO
5316 && is_opcode_valid (amo
)
5317 && is_size_valid (amo
))
5319 if (is_delay_slot_valid (amo
))
5329 gas_assert (amo
->name
);
5331 while (strcmp (name
, amo
->name
) == 0);
5334 create_insn (&insn
, mo
);
5352 INSERT_OPERAND (mips_opts
.micromips
,
5353 EXTLSB
, insn
, va_arg (args
, int));
5358 /* Note that in the macro case, these arguments are already
5359 in MSB form. (When handling the instruction in the
5360 non-macro case, these arguments are sizes from which
5361 MSB values must be calculated.) */
5362 INSERT_OPERAND (mips_opts
.micromips
,
5363 INSMSB
, insn
, va_arg (args
, int));
5367 gas_assert (!mips_opts
.micromips
);
5368 INSERT_OPERAND (0, CODE10
, insn
, va_arg (args
, int));
5374 /* Note that in the macro case, these arguments are already
5375 in MSBD form. (When handling the instruction in the
5376 non-macro case, these arguments are sizes from which
5377 MSBD values must be calculated.) */
5378 INSERT_OPERAND (mips_opts
.micromips
,
5379 EXTMSBD
, insn
, va_arg (args
, int));
5383 gas_assert (!mips_opts
.micromips
);
5384 INSERT_OPERAND (0, SEQI
, insn
, va_arg (args
, int));
5388 INSERT_OPERAND (mips_opts
.micromips
, EVAOFFSET
, insn
, va_arg (args
, int));
5397 INSERT_OPERAND (mips_opts
.micromips
, BP
, insn
, va_arg (args
, int));
5401 gas_assert (mips_opts
.micromips
);
5405 INSERT_OPERAND (mips_opts
.micromips
, RT
, insn
, va_arg (args
, int));
5409 INSERT_OPERAND (mips_opts
.micromips
, CODE
, insn
, va_arg (args
, int));
5413 gas_assert (!mips_opts
.micromips
);
5415 INSERT_OPERAND (mips_opts
.micromips
, FT
, insn
, va_arg (args
, int));
5419 if (mips_opts
.micromips
)
5420 INSERT_OPERAND (1, RS
, insn
, va_arg (args
, int));
5422 INSERT_OPERAND (0, RD
, insn
, va_arg (args
, int));
5426 gas_assert (!mips_opts
.micromips
);
5428 INSERT_OPERAND (mips_opts
.micromips
, RD
, insn
, va_arg (args
, int));
5432 gas_assert (!mips_opts
.micromips
);
5434 int tmp
= va_arg (args
, int);
5436 INSERT_OPERAND (0, RT
, insn
, tmp
);
5437 INSERT_OPERAND (0, RD
, insn
, tmp
);
5443 gas_assert (!mips_opts
.micromips
);
5444 INSERT_OPERAND (0, FS
, insn
, va_arg (args
, int));
5451 INSERT_OPERAND (mips_opts
.micromips
,
5452 SHAMT
, insn
, va_arg (args
, int));
5456 gas_assert (!mips_opts
.micromips
);
5457 INSERT_OPERAND (0, FD
, insn
, va_arg (args
, int));
5461 gas_assert (!mips_opts
.micromips
);
5462 INSERT_OPERAND (0, CODE20
, insn
, va_arg (args
, int));
5466 gas_assert (!mips_opts
.micromips
);
5467 INSERT_OPERAND (0, CODE19
, insn
, va_arg (args
, int));
5471 gas_assert (!mips_opts
.micromips
);
5472 INSERT_OPERAND (0, CODE2
, insn
, va_arg (args
, int));
5479 INSERT_OPERAND (mips_opts
.micromips
, RS
, insn
, va_arg (args
, int));
5484 macro_read_relocs (&args
, r
);
5485 gas_assert (*r
== BFD_RELOC_GPREL16
5486 || *r
== BFD_RELOC_MIPS_HIGHER
5487 || *r
== BFD_RELOC_HI16_S
5488 || *r
== BFD_RELOC_LO16
5489 || *r
== BFD_RELOC_MIPS_GOT_OFST
);
5493 macro_read_relocs (&args
, r
);
5497 macro_read_relocs (&args
, r
);
5498 gas_assert (ep
!= NULL
5499 && (ep
->X_op
== O_constant
5500 || (ep
->X_op
== O_symbol
5501 && (*r
== BFD_RELOC_MIPS_HIGHEST
5502 || *r
== BFD_RELOC_HI16_S
5503 || *r
== BFD_RELOC_HI16
5504 || *r
== BFD_RELOC_GPREL16
5505 || *r
== BFD_RELOC_MIPS_GOT_HI16
5506 || *r
== BFD_RELOC_MIPS_CALL_HI16
))));
5510 gas_assert (ep
!= NULL
);
5513 * This allows macro() to pass an immediate expression for
5514 * creating short branches without creating a symbol.
5516 * We don't allow branch relaxation for these branches, as
5517 * they should only appear in ".set nomacro" anyway.
5519 if (ep
->X_op
== O_constant
)
5521 /* For microMIPS we always use relocations for branches.
5522 So we should not resolve immediate values. */
5523 gas_assert (!mips_opts
.micromips
);
5525 if ((ep
->X_add_number
& 3) != 0)
5526 as_bad (_("branch to misaligned address (0x%lx)"),
5527 (unsigned long) ep
->X_add_number
);
5528 if ((ep
->X_add_number
+ 0x20000) & ~0x3ffff)
5529 as_bad (_("branch address range overflow (0x%lx)"),
5530 (unsigned long) ep
->X_add_number
);
5531 insn
.insn_opcode
|= (ep
->X_add_number
>> 2) & 0xffff;
5535 *r
= BFD_RELOC_16_PCREL_S2
;
5539 gas_assert (ep
!= NULL
);
5540 *r
= BFD_RELOC_MIPS_JMP
;
5544 gas_assert (!mips_opts
.micromips
);
5545 INSERT_OPERAND (0, COPZ
, insn
, va_arg (args
, unsigned long));
5549 INSERT_OPERAND (mips_opts
.micromips
,
5550 CACHE
, insn
, va_arg (args
, unsigned long));
5554 gas_assert (mips_opts
.micromips
);
5555 INSERT_OPERAND (1, TRAP
, insn
, va_arg (args
, int));
5559 gas_assert (mips_opts
.micromips
);
5560 INSERT_OPERAND (1, OFFSET10
, insn
, va_arg (args
, int));
5564 INSERT_OPERAND (mips_opts
.micromips
,
5565 3BITPOS
, insn
, va_arg (args
, unsigned int));
5569 INSERT_OPERAND (mips_opts
.micromips
,
5570 OFFSET12
, insn
, va_arg (args
, unsigned long));
5574 gas_assert (mips_opts
.micromips
);
5575 INSERT_OPERAND (1, BCC
, insn
, va_arg (args
, int));
5578 case 'm': /* Opcode extension character. */
5579 gas_assert (mips_opts
.micromips
);
5583 INSERT_OPERAND (1, MJ
, insn
, va_arg (args
, int));
5587 INSERT_OPERAND (1, MP
, insn
, va_arg (args
, int));
5591 INSERT_OPERAND (1, IMMF
, insn
, va_arg (args
, int));
5605 gas_assert (*r
== BFD_RELOC_UNUSED
? ep
== NULL
: ep
!= NULL
);
5607 append_insn (&insn
, ep
, r
, TRUE
);
5611 mips16_macro_build (expressionS
*ep
, const char *name
, const char *fmt
,
5614 struct mips_opcode
*mo
;
5615 struct mips_cl_insn insn
;
5616 bfd_reloc_code_real_type r
[3]
5617 = {BFD_RELOC_UNUSED
, BFD_RELOC_UNUSED
, BFD_RELOC_UNUSED
};
5619 mo
= (struct mips_opcode
*) hash_find (mips16_op_hash
, name
);
5621 gas_assert (strcmp (name
, mo
->name
) == 0);
5623 while (strcmp (fmt
, mo
->args
) != 0 || mo
->pinfo
== INSN_MACRO
)
5626 gas_assert (mo
->name
);
5627 gas_assert (strcmp (name
, mo
->name
) == 0);
5630 create_insn (&insn
, mo
);
5648 MIPS16_INSERT_OPERAND (RY
, insn
, va_arg (*args
, int));
5653 MIPS16_INSERT_OPERAND (RX
, insn
, va_arg (*args
, int));
5657 MIPS16_INSERT_OPERAND (RZ
, insn
, va_arg (*args
, int));
5661 MIPS16_INSERT_OPERAND (MOVE32Z
, insn
, va_arg (*args
, int));
5671 MIPS16_INSERT_OPERAND (REGR32
, insn
, va_arg (*args
, int));
5678 regno
= va_arg (*args
, int);
5679 regno
= ((regno
& 7) << 2) | ((regno
& 0x18) >> 3);
5680 MIPS16_INSERT_OPERAND (REG32R
, insn
, regno
);
5703 gas_assert (ep
!= NULL
);
5705 if (ep
->X_op
!= O_constant
)
5706 *r
= (int) BFD_RELOC_UNUSED
+ c
;
5707 else if (calculate_reloc (*r
, ep
->X_add_number
, &value
))
5709 mips16_immed (NULL
, 0, c
, *r
, value
, 0, &insn
.insn_opcode
);
5711 *r
= BFD_RELOC_UNUSED
;
5717 MIPS16_INSERT_OPERAND (IMM6
, insn
, va_arg (*args
, int));
5724 gas_assert (*r
== BFD_RELOC_UNUSED
? ep
== NULL
: ep
!= NULL
);
5726 append_insn (&insn
, ep
, r
, TRUE
);
5730 * Sign-extend 32-bit mode constants that have bit 31 set and all
5731 * higher bits unset.
5734 normalize_constant_expr (expressionS
*ex
)
5736 if (ex
->X_op
== O_constant
5737 && IS_ZEXT_32BIT_NUM (ex
->X_add_number
))
5738 ex
->X_add_number
= (((ex
->X_add_number
& 0xffffffff) ^ 0x80000000)
5743 * Sign-extend 32-bit mode address offsets that have bit 31 set and
5744 * all higher bits unset.
5747 normalize_address_expr (expressionS
*ex
)
5749 if (((ex
->X_op
== O_constant
&& HAVE_32BIT_ADDRESSES
)
5750 || (ex
->X_op
== O_symbol
&& HAVE_32BIT_SYMBOLS
))
5751 && IS_ZEXT_32BIT_NUM (ex
->X_add_number
))
5752 ex
->X_add_number
= (((ex
->X_add_number
& 0xffffffff) ^ 0x80000000)
5757 * Generate a "jalr" instruction with a relocation hint to the called
5758 * function. This occurs in NewABI PIC code.
5761 macro_build_jalr (expressionS
*ep
, int cprestore
)
5763 static const bfd_reloc_code_real_type jalr_relocs
[2]
5764 = { BFD_RELOC_MIPS_JALR
, BFD_RELOC_MICROMIPS_JALR
};
5765 bfd_reloc_code_real_type jalr_reloc
= jalr_relocs
[mips_opts
.micromips
];
5769 if (MIPS_JALR_HINT_P (ep
))
5774 if (mips_opts
.micromips
)
5776 jalr
= ((mips_opts
.noreorder
&& !cprestore
) || mips_opts
.insn32
5777 ? "jalr" : "jalrs");
5778 if (MIPS_JALR_HINT_P (ep
)
5780 || (history
[0].insn_mo
->pinfo2
& INSN2_BRANCH_DELAY_32BIT
))
5781 macro_build (NULL
, jalr
, "t,s", RA
, PIC_CALL_REG
);
5783 macro_build (NULL
, jalr
, "mj", PIC_CALL_REG
);
5786 macro_build (NULL
, "jalr", "d,s", RA
, PIC_CALL_REG
);
5787 if (MIPS_JALR_HINT_P (ep
))
5788 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4, ep
, FALSE
, jalr_reloc
);
5792 * Generate a "lui" instruction.
5795 macro_build_lui (expressionS
*ep
, int regnum
)
5797 gas_assert (! mips_opts
.mips16
);
5799 if (ep
->X_op
!= O_constant
)
5801 gas_assert (ep
->X_op
== O_symbol
);
5802 /* _gp_disp is a special case, used from s_cpload.
5803 __gnu_local_gp is used if mips_no_shared. */
5804 gas_assert (mips_pic
== NO_PIC
5806 && strcmp (S_GET_NAME (ep
->X_add_symbol
), "_gp_disp") == 0)
5807 || (! mips_in_shared
5808 && strcmp (S_GET_NAME (ep
->X_add_symbol
),
5809 "__gnu_local_gp") == 0));
5812 macro_build (ep
, "lui", LUI_FMT
, regnum
, BFD_RELOC_HI16_S
);
5815 /* Generate a sequence of instructions to do a load or store from a constant
5816 offset off of a base register (breg) into/from a target register (treg),
5817 using AT if necessary. */
5819 macro_build_ldst_constoffset (expressionS
*ep
, const char *op
,
5820 int treg
, int breg
, int dbl
)
5822 gas_assert (ep
->X_op
== O_constant
);
5824 /* Sign-extending 32-bit constants makes their handling easier. */
5826 normalize_constant_expr (ep
);
5828 /* Right now, this routine can only handle signed 32-bit constants. */
5829 if (! IS_SEXT_32BIT_NUM(ep
->X_add_number
+ 0x8000))
5830 as_warn (_("operand overflow"));
5832 if (IS_SEXT_16BIT_NUM(ep
->X_add_number
))
5834 /* Signed 16-bit offset will fit in the op. Easy! */
5835 macro_build (ep
, op
, "t,o(b)", treg
, BFD_RELOC_LO16
, breg
);
5839 /* 32-bit offset, need multiple instructions and AT, like:
5840 lui $tempreg,const_hi (BFD_RELOC_HI16_S)
5841 addu $tempreg,$tempreg,$breg
5842 <op> $treg,const_lo($tempreg) (BFD_RELOC_LO16)
5843 to handle the complete offset. */
5844 macro_build_lui (ep
, AT
);
5845 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t", AT
, AT
, breg
);
5846 macro_build (ep
, op
, "t,o(b)", treg
, BFD_RELOC_LO16
, AT
);
5849 as_bad (_("Macro used $at after \".set noat\""));
5854 * Generates code to set the $at register to true (one)
5855 * if reg is less than the immediate expression.
5858 set_at (int reg
, int unsignedp
)
5860 if (imm_expr
.X_op
== O_constant
5861 && imm_expr
.X_add_number
>= -0x8000
5862 && imm_expr
.X_add_number
< 0x8000)
5863 macro_build (&imm_expr
, unsignedp
? "sltiu" : "slti", "t,r,j",
5864 AT
, reg
, BFD_RELOC_LO16
);
5867 load_register (AT
, &imm_expr
, HAVE_64BIT_GPRS
);
5868 macro_build (NULL
, unsignedp
? "sltu" : "slt", "d,v,t", AT
, reg
, AT
);
5872 /* Warn if an expression is not a constant. */
5875 check_absolute_expr (struct mips_cl_insn
*ip
, expressionS
*ex
)
5877 if (ex
->X_op
== O_big
)
5878 as_bad (_("unsupported large constant"));
5879 else if (ex
->X_op
!= O_constant
)
5880 as_bad (_("Instruction %s requires absolute expression"),
5883 if (HAVE_32BIT_GPRS
)
5884 normalize_constant_expr (ex
);
5887 /* Count the leading zeroes by performing a binary chop. This is a
5888 bulky bit of source, but performance is a LOT better for the
5889 majority of values than a simple loop to count the bits:
5890 for (lcnt = 0; (lcnt < 32); lcnt++)
5891 if ((v) & (1 << (31 - lcnt)))
5893 However it is not code size friendly, and the gain will drop a bit
5894 on certain cached systems.
5896 #define COUNT_TOP_ZEROES(v) \
5897 (((v) & ~0xffff) == 0 \
5898 ? ((v) & ~0xff) == 0 \
5899 ? ((v) & ~0xf) == 0 \
5900 ? ((v) & ~0x3) == 0 \
5901 ? ((v) & ~0x1) == 0 \
5906 : ((v) & ~0x7) == 0 \
5909 : ((v) & ~0x3f) == 0 \
5910 ? ((v) & ~0x1f) == 0 \
5913 : ((v) & ~0x7f) == 0 \
5916 : ((v) & ~0xfff) == 0 \
5917 ? ((v) & ~0x3ff) == 0 \
5918 ? ((v) & ~0x1ff) == 0 \
5921 : ((v) & ~0x7ff) == 0 \
5924 : ((v) & ~0x3fff) == 0 \
5925 ? ((v) & ~0x1fff) == 0 \
5928 : ((v) & ~0x7fff) == 0 \
5931 : ((v) & ~0xffffff) == 0 \
5932 ? ((v) & ~0xfffff) == 0 \
5933 ? ((v) & ~0x3ffff) == 0 \
5934 ? ((v) & ~0x1ffff) == 0 \
5937 : ((v) & ~0x7ffff) == 0 \
5940 : ((v) & ~0x3fffff) == 0 \
5941 ? ((v) & ~0x1fffff) == 0 \
5944 : ((v) & ~0x7fffff) == 0 \
5947 : ((v) & ~0xfffffff) == 0 \
5948 ? ((v) & ~0x3ffffff) == 0 \
5949 ? ((v) & ~0x1ffffff) == 0 \
5952 : ((v) & ~0x7ffffff) == 0 \
5955 : ((v) & ~0x3fffffff) == 0 \
5956 ? ((v) & ~0x1fffffff) == 0 \
5959 : ((v) & ~0x7fffffff) == 0 \
5964 * This routine generates the least number of instructions necessary to load
5965 * an absolute expression value into a register.
5968 load_register (int reg
, expressionS
*ep
, int dbl
)
5971 expressionS hi32
, lo32
;
5973 if (ep
->X_op
!= O_big
)
5975 gas_assert (ep
->X_op
== O_constant
);
5977 /* Sign-extending 32-bit constants makes their handling easier. */
5979 normalize_constant_expr (ep
);
5981 if (IS_SEXT_16BIT_NUM (ep
->X_add_number
))
5983 /* We can handle 16 bit signed values with an addiu to
5984 $zero. No need to ever use daddiu here, since $zero and
5985 the result are always correct in 32 bit mode. */
5986 macro_build (ep
, "addiu", "t,r,j", reg
, 0, BFD_RELOC_LO16
);
5989 else if (ep
->X_add_number
>= 0 && ep
->X_add_number
< 0x10000)
5991 /* We can handle 16 bit unsigned values with an ori to
5993 macro_build (ep
, "ori", "t,r,i", reg
, 0, BFD_RELOC_LO16
);
5996 else if ((IS_SEXT_32BIT_NUM (ep
->X_add_number
)))
5998 /* 32 bit values require an lui. */
5999 macro_build (ep
, "lui", LUI_FMT
, reg
, BFD_RELOC_HI16
);
6000 if ((ep
->X_add_number
& 0xffff) != 0)
6001 macro_build (ep
, "ori", "t,r,i", reg
, reg
, BFD_RELOC_LO16
);
6006 /* The value is larger than 32 bits. */
6008 if (!dbl
|| HAVE_32BIT_GPRS
)
6012 sprintf_vma (value
, ep
->X_add_number
);
6013 as_bad (_("Number (0x%s) larger than 32 bits"), value
);
6014 macro_build (ep
, "addiu", "t,r,j", reg
, 0, BFD_RELOC_LO16
);
6018 if (ep
->X_op
!= O_big
)
6021 hi32
.X_add_number
= (valueT
) hi32
.X_add_number
>> 16;
6022 hi32
.X_add_number
= (valueT
) hi32
.X_add_number
>> 16;
6023 hi32
.X_add_number
&= 0xffffffff;
6025 lo32
.X_add_number
&= 0xffffffff;
6029 gas_assert (ep
->X_add_number
> 2);
6030 if (ep
->X_add_number
== 3)
6031 generic_bignum
[3] = 0;
6032 else if (ep
->X_add_number
> 4)
6033 as_bad (_("Number larger than 64 bits"));
6034 lo32
.X_op
= O_constant
;
6035 lo32
.X_add_number
= generic_bignum
[0] + (generic_bignum
[1] << 16);
6036 hi32
.X_op
= O_constant
;
6037 hi32
.X_add_number
= generic_bignum
[2] + (generic_bignum
[3] << 16);
6040 if (hi32
.X_add_number
== 0)
6045 unsigned long hi
, lo
;
6047 if (hi32
.X_add_number
== (offsetT
) 0xffffffff)
6049 if ((lo32
.X_add_number
& 0xffff8000) == 0xffff8000)
6051 macro_build (&lo32
, "addiu", "t,r,j", reg
, 0, BFD_RELOC_LO16
);
6054 if (lo32
.X_add_number
& 0x80000000)
6056 macro_build (&lo32
, "lui", LUI_FMT
, reg
, BFD_RELOC_HI16
);
6057 if (lo32
.X_add_number
& 0xffff)
6058 macro_build (&lo32
, "ori", "t,r,i", reg
, reg
, BFD_RELOC_LO16
);
6063 /* Check for 16bit shifted constant. We know that hi32 is
6064 non-zero, so start the mask on the first bit of the hi32
6069 unsigned long himask
, lomask
;
6073 himask
= 0xffff >> (32 - shift
);
6074 lomask
= (0xffff << shift
) & 0xffffffff;
6078 himask
= 0xffff << (shift
- 32);
6081 if ((hi32
.X_add_number
& ~(offsetT
) himask
) == 0
6082 && (lo32
.X_add_number
& ~(offsetT
) lomask
) == 0)
6086 tmp
.X_op
= O_constant
;
6088 tmp
.X_add_number
= ((hi32
.X_add_number
<< (32 - shift
))
6089 | (lo32
.X_add_number
>> shift
));
6091 tmp
.X_add_number
= hi32
.X_add_number
>> (shift
- 32);
6092 macro_build (&tmp
, "ori", "t,r,i", reg
, 0, BFD_RELOC_LO16
);
6093 macro_build (NULL
, (shift
>= 32) ? "dsll32" : "dsll", SHFT_FMT
,
6094 reg
, reg
, (shift
>= 32) ? shift
- 32 : shift
);
6099 while (shift
<= (64 - 16));
6101 /* Find the bit number of the lowest one bit, and store the
6102 shifted value in hi/lo. */
6103 hi
= (unsigned long) (hi32
.X_add_number
& 0xffffffff);
6104 lo
= (unsigned long) (lo32
.X_add_number
& 0xffffffff);
6108 while ((lo
& 1) == 0)
6113 lo
|= (hi
& (((unsigned long) 1 << bit
) - 1)) << (32 - bit
);
6119 while ((hi
& 1) == 0)
6128 /* Optimize if the shifted value is a (power of 2) - 1. */
6129 if ((hi
== 0 && ((lo
+ 1) & lo
) == 0)
6130 || (lo
== 0xffffffff && ((hi
+ 1) & hi
) == 0))
6132 shift
= COUNT_TOP_ZEROES ((unsigned int) hi32
.X_add_number
);
6137 /* This instruction will set the register to be all
6139 tmp
.X_op
= O_constant
;
6140 tmp
.X_add_number
= (offsetT
) -1;
6141 macro_build (&tmp
, "addiu", "t,r,j", reg
, 0, BFD_RELOC_LO16
);
6145 macro_build (NULL
, (bit
>= 32) ? "dsll32" : "dsll", SHFT_FMT
,
6146 reg
, reg
, (bit
>= 32) ? bit
- 32 : bit
);
6148 macro_build (NULL
, (shift
>= 32) ? "dsrl32" : "dsrl", SHFT_FMT
,
6149 reg
, reg
, (shift
>= 32) ? shift
- 32 : shift
);
6154 /* Sign extend hi32 before calling load_register, because we can
6155 generally get better code when we load a sign extended value. */
6156 if ((hi32
.X_add_number
& 0x80000000) != 0)
6157 hi32
.X_add_number
|= ~(offsetT
) 0xffffffff;
6158 load_register (reg
, &hi32
, 0);
6161 if ((lo32
.X_add_number
& 0xffff0000) == 0)
6165 macro_build (NULL
, "dsll32", SHFT_FMT
, reg
, freg
, 0);
6173 if ((freg
== 0) && (lo32
.X_add_number
== (offsetT
) 0xffffffff))
6175 macro_build (&lo32
, "lui", LUI_FMT
, reg
, BFD_RELOC_HI16
);
6176 macro_build (NULL
, "dsrl32", SHFT_FMT
, reg
, reg
, 0);
6182 macro_build (NULL
, "dsll", SHFT_FMT
, reg
, freg
, 16);
6186 mid16
.X_add_number
>>= 16;
6187 macro_build (&mid16
, "ori", "t,r,i", reg
, freg
, BFD_RELOC_LO16
);
6188 macro_build (NULL
, "dsll", SHFT_FMT
, reg
, reg
, 16);
6191 if ((lo32
.X_add_number
& 0xffff) != 0)
6192 macro_build (&lo32
, "ori", "t,r,i", reg
, freg
, BFD_RELOC_LO16
);
6196 load_delay_nop (void)
6198 if (!gpr_interlocks
)
6199 macro_build (NULL
, "nop", "");
6202 /* Load an address into a register. */
6205 load_address (int reg
, expressionS
*ep
, int *used_at
)
6207 if (ep
->X_op
!= O_constant
6208 && ep
->X_op
!= O_symbol
)
6210 as_bad (_("expression too complex"));
6211 ep
->X_op
= O_constant
;
6214 if (ep
->X_op
== O_constant
)
6216 load_register (reg
, ep
, HAVE_64BIT_ADDRESSES
);
6220 if (mips_pic
== NO_PIC
)
6222 /* If this is a reference to a GP relative symbol, we want
6223 addiu $reg,$gp,<sym> (BFD_RELOC_GPREL16)
6225 lui $reg,<sym> (BFD_RELOC_HI16_S)
6226 addiu $reg,$reg,<sym> (BFD_RELOC_LO16)
6227 If we have an addend, we always use the latter form.
6229 With 64bit address space and a usable $at we want
6230 lui $reg,<sym> (BFD_RELOC_MIPS_HIGHEST)
6231 lui $at,<sym> (BFD_RELOC_HI16_S)
6232 daddiu $reg,<sym> (BFD_RELOC_MIPS_HIGHER)
6233 daddiu $at,<sym> (BFD_RELOC_LO16)
6237 If $at is already in use, we use a path which is suboptimal
6238 on superscalar processors.
6239 lui $reg,<sym> (BFD_RELOC_MIPS_HIGHEST)
6240 daddiu $reg,<sym> (BFD_RELOC_MIPS_HIGHER)
6242 daddiu $reg,<sym> (BFD_RELOC_HI16_S)
6244 daddiu $reg,<sym> (BFD_RELOC_LO16)
6246 For GP relative symbols in 64bit address space we can use
6247 the same sequence as in 32bit address space. */
6248 if (HAVE_64BIT_SYMBOLS
)
6250 if ((valueT
) ep
->X_add_number
<= MAX_GPREL_OFFSET
6251 && !nopic_need_relax (ep
->X_add_symbol
, 1))
6253 relax_start (ep
->X_add_symbol
);
6254 macro_build (ep
, ADDRESS_ADDI_INSN
, "t,r,j", reg
,
6255 mips_gp_register
, BFD_RELOC_GPREL16
);
6259 if (*used_at
== 0 && mips_opts
.at
)
6261 macro_build (ep
, "lui", LUI_FMT
, reg
, BFD_RELOC_MIPS_HIGHEST
);
6262 macro_build (ep
, "lui", LUI_FMT
, AT
, BFD_RELOC_HI16_S
);
6263 macro_build (ep
, "daddiu", "t,r,j", reg
, reg
,
6264 BFD_RELOC_MIPS_HIGHER
);
6265 macro_build (ep
, "daddiu", "t,r,j", AT
, AT
, BFD_RELOC_LO16
);
6266 macro_build (NULL
, "dsll32", SHFT_FMT
, reg
, reg
, 0);
6267 macro_build (NULL
, "daddu", "d,v,t", reg
, reg
, AT
);
6272 macro_build (ep
, "lui", LUI_FMT
, reg
, BFD_RELOC_MIPS_HIGHEST
);
6273 macro_build (ep
, "daddiu", "t,r,j", reg
, reg
,
6274 BFD_RELOC_MIPS_HIGHER
);
6275 macro_build (NULL
, "dsll", SHFT_FMT
, reg
, reg
, 16);
6276 macro_build (ep
, "daddiu", "t,r,j", reg
, reg
, BFD_RELOC_HI16_S
);
6277 macro_build (NULL
, "dsll", SHFT_FMT
, reg
, reg
, 16);
6278 macro_build (ep
, "daddiu", "t,r,j", reg
, reg
, BFD_RELOC_LO16
);
6281 if (mips_relax
.sequence
)
6286 if ((valueT
) ep
->X_add_number
<= MAX_GPREL_OFFSET
6287 && !nopic_need_relax (ep
->X_add_symbol
, 1))
6289 relax_start (ep
->X_add_symbol
);
6290 macro_build (ep
, ADDRESS_ADDI_INSN
, "t,r,j", reg
,
6291 mips_gp_register
, BFD_RELOC_GPREL16
);
6294 macro_build_lui (ep
, reg
);
6295 macro_build (ep
, ADDRESS_ADDI_INSN
, "t,r,j",
6296 reg
, reg
, BFD_RELOC_LO16
);
6297 if (mips_relax
.sequence
)
6301 else if (!mips_big_got
)
6305 /* If this is a reference to an external symbol, we want
6306 lw $reg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
6308 lw $reg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
6310 addiu $reg,$reg,<sym> (BFD_RELOC_LO16)
6311 If there is a constant, it must be added in after.
6313 If we have NewABI, we want
6314 lw $reg,<sym+cst>($gp) (BFD_RELOC_MIPS_GOT_DISP)
6315 unless we're referencing a global symbol with a non-zero
6316 offset, in which case cst must be added separately. */
6319 if (ep
->X_add_number
)
6321 ex
.X_add_number
= ep
->X_add_number
;
6322 ep
->X_add_number
= 0;
6323 relax_start (ep
->X_add_symbol
);
6324 macro_build (ep
, ADDRESS_LOAD_INSN
, "t,o(b)", reg
,
6325 BFD_RELOC_MIPS_GOT_DISP
, mips_gp_register
);
6326 if (ex
.X_add_number
< -0x8000 || ex
.X_add_number
>= 0x8000)
6327 as_bad (_("PIC code offset overflow (max 16 signed bits)"));
6328 ex
.X_op
= O_constant
;
6329 macro_build (&ex
, ADDRESS_ADDI_INSN
, "t,r,j",
6330 reg
, reg
, BFD_RELOC_LO16
);
6331 ep
->X_add_number
= ex
.X_add_number
;
6334 macro_build (ep
, ADDRESS_LOAD_INSN
, "t,o(b)", reg
,
6335 BFD_RELOC_MIPS_GOT_DISP
, mips_gp_register
);
6336 if (mips_relax
.sequence
)
6341 ex
.X_add_number
= ep
->X_add_number
;
6342 ep
->X_add_number
= 0;
6343 macro_build (ep
, ADDRESS_LOAD_INSN
, "t,o(b)", reg
,
6344 BFD_RELOC_MIPS_GOT16
, mips_gp_register
);
6346 relax_start (ep
->X_add_symbol
);
6348 macro_build (ep
, ADDRESS_ADDI_INSN
, "t,r,j", reg
, reg
,
6352 if (ex
.X_add_number
!= 0)
6354 if (ex
.X_add_number
< -0x8000 || ex
.X_add_number
>= 0x8000)
6355 as_bad (_("PIC code offset overflow (max 16 signed bits)"));
6356 ex
.X_op
= O_constant
;
6357 macro_build (&ex
, ADDRESS_ADDI_INSN
, "t,r,j",
6358 reg
, reg
, BFD_RELOC_LO16
);
6362 else if (mips_big_got
)
6366 /* This is the large GOT case. If this is a reference to an
6367 external symbol, we want
6368 lui $reg,<sym> (BFD_RELOC_MIPS_GOT_HI16)
6370 lw $reg,<sym>($reg) (BFD_RELOC_MIPS_GOT_LO16)
6372 Otherwise, for a reference to a local symbol in old ABI, we want
6373 lw $reg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
6375 addiu $reg,$reg,<sym> (BFD_RELOC_LO16)
6376 If there is a constant, it must be added in after.
6378 In the NewABI, for local symbols, with or without offsets, we want:
6379 lw $reg,<sym>($gp) (BFD_RELOC_MIPS_GOT_PAGE)
6380 addiu $reg,$reg,<sym> (BFD_RELOC_MIPS_GOT_OFST)
6384 ex
.X_add_number
= ep
->X_add_number
;
6385 ep
->X_add_number
= 0;
6386 relax_start (ep
->X_add_symbol
);
6387 macro_build (ep
, "lui", LUI_FMT
, reg
, BFD_RELOC_MIPS_GOT_HI16
);
6388 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
6389 reg
, reg
, mips_gp_register
);
6390 macro_build (ep
, ADDRESS_LOAD_INSN
, "t,o(b)",
6391 reg
, BFD_RELOC_MIPS_GOT_LO16
, reg
);
6392 if (ex
.X_add_number
< -0x8000 || ex
.X_add_number
>= 0x8000)
6393 as_bad (_("PIC code offset overflow (max 16 signed bits)"));
6394 else if (ex
.X_add_number
)
6396 ex
.X_op
= O_constant
;
6397 macro_build (&ex
, ADDRESS_ADDI_INSN
, "t,r,j", reg
, reg
,
6401 ep
->X_add_number
= ex
.X_add_number
;
6403 macro_build (ep
, ADDRESS_LOAD_INSN
, "t,o(b)", reg
,
6404 BFD_RELOC_MIPS_GOT_PAGE
, mips_gp_register
);
6405 macro_build (ep
, ADDRESS_ADDI_INSN
, "t,r,j", reg
, reg
,
6406 BFD_RELOC_MIPS_GOT_OFST
);
6411 ex
.X_add_number
= ep
->X_add_number
;
6412 ep
->X_add_number
= 0;
6413 relax_start (ep
->X_add_symbol
);
6414 macro_build (ep
, "lui", LUI_FMT
, reg
, BFD_RELOC_MIPS_GOT_HI16
);
6415 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
6416 reg
, reg
, mips_gp_register
);
6417 macro_build (ep
, ADDRESS_LOAD_INSN
, "t,o(b)",
6418 reg
, BFD_RELOC_MIPS_GOT_LO16
, reg
);
6420 if (reg_needs_delay (mips_gp_register
))
6422 /* We need a nop before loading from $gp. This special
6423 check is required because the lui which starts the main
6424 instruction stream does not refer to $gp, and so will not
6425 insert the nop which may be required. */
6426 macro_build (NULL
, "nop", "");
6428 macro_build (ep
, ADDRESS_LOAD_INSN
, "t,o(b)", reg
,
6429 BFD_RELOC_MIPS_GOT16
, mips_gp_register
);
6431 macro_build (ep
, ADDRESS_ADDI_INSN
, "t,r,j", reg
, reg
,
6435 if (ex
.X_add_number
!= 0)
6437 if (ex
.X_add_number
< -0x8000 || ex
.X_add_number
>= 0x8000)
6438 as_bad (_("PIC code offset overflow (max 16 signed bits)"));
6439 ex
.X_op
= O_constant
;
6440 macro_build (&ex
, ADDRESS_ADDI_INSN
, "t,r,j", reg
, reg
,
6448 if (!mips_opts
.at
&& *used_at
== 1)
6449 as_bad (_("Macro used $at after \".set noat\""));
6452 /* Move the contents of register SOURCE into register DEST. */
6455 move_register (int dest
, int source
)
6457 /* Prefer to use a 16-bit microMIPS instruction unless the previous
6458 instruction specifically requires a 32-bit one. */
6459 if (mips_opts
.micromips
6460 && !mips_opts
.insn32
6461 && !(history
[0].insn_mo
->pinfo2
& INSN2_BRANCH_DELAY_32BIT
))
6462 macro_build (NULL
, "move", "mp,mj", dest
, source
);
6464 macro_build (NULL
, HAVE_32BIT_GPRS
? "addu" : "daddu", "d,v,t",
6468 /* Emit an SVR4 PIC sequence to load address LOCAL into DEST, where
6469 LOCAL is the sum of a symbol and a 16-bit or 32-bit displacement.
6470 The two alternatives are:
6472 Global symbol Local sybmol
6473 ------------- ------------
6474 lw DEST,%got(SYMBOL) lw DEST,%got(SYMBOL + OFFSET)
6476 addiu DEST,DEST,OFFSET addiu DEST,DEST,%lo(SYMBOL + OFFSET)
6478 load_got_offset emits the first instruction and add_got_offset
6479 emits the second for a 16-bit offset or add_got_offset_hilo emits
6480 a sequence to add a 32-bit offset using a scratch register. */
6483 load_got_offset (int dest
, expressionS
*local
)
6488 global
.X_add_number
= 0;
6490 relax_start (local
->X_add_symbol
);
6491 macro_build (&global
, ADDRESS_LOAD_INSN
, "t,o(b)", dest
,
6492 BFD_RELOC_MIPS_GOT16
, mips_gp_register
);
6494 macro_build (local
, ADDRESS_LOAD_INSN
, "t,o(b)", dest
,
6495 BFD_RELOC_MIPS_GOT16
, mips_gp_register
);
6500 add_got_offset (int dest
, expressionS
*local
)
6504 global
.X_op
= O_constant
;
6505 global
.X_op_symbol
= NULL
;
6506 global
.X_add_symbol
= NULL
;
6507 global
.X_add_number
= local
->X_add_number
;
6509 relax_start (local
->X_add_symbol
);
6510 macro_build (&global
, ADDRESS_ADDI_INSN
, "t,r,j",
6511 dest
, dest
, BFD_RELOC_LO16
);
6513 macro_build (local
, ADDRESS_ADDI_INSN
, "t,r,j", dest
, dest
, BFD_RELOC_LO16
);
6518 add_got_offset_hilo (int dest
, expressionS
*local
, int tmp
)
6521 int hold_mips_optimize
;
6523 global
.X_op
= O_constant
;
6524 global
.X_op_symbol
= NULL
;
6525 global
.X_add_symbol
= NULL
;
6526 global
.X_add_number
= local
->X_add_number
;
6528 relax_start (local
->X_add_symbol
);
6529 load_register (tmp
, &global
, HAVE_64BIT_ADDRESSES
);
6531 /* Set mips_optimize around the lui instruction to avoid
6532 inserting an unnecessary nop after the lw. */
6533 hold_mips_optimize
= mips_optimize
;
6535 macro_build_lui (&global
, tmp
);
6536 mips_optimize
= hold_mips_optimize
;
6537 macro_build (local
, ADDRESS_ADDI_INSN
, "t,r,j", tmp
, tmp
, BFD_RELOC_LO16
);
6540 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t", dest
, dest
, tmp
);
6543 /* Emit a sequence of instructions to emulate a branch likely operation.
6544 BR is an ordinary branch corresponding to one to be emulated. BRNEG
6545 is its complementing branch with the original condition negated.
6546 CALL is set if the original branch specified the link operation.
6547 EP, FMT, SREG and TREG specify the usual macro_build() parameters.
6549 Code like this is produced in the noreorder mode:
6554 delay slot (executed only if branch taken)
6562 delay slot (executed only if branch taken)
6565 In the reorder mode the delay slot would be filled with a nop anyway,
6566 so code produced is simply:
6571 This function is used when producing code for the microMIPS ASE that
6572 does not implement branch likely instructions in hardware. */
6575 macro_build_branch_likely (const char *br
, const char *brneg
,
6576 int call
, expressionS
*ep
, const char *fmt
,
6577 unsigned int sreg
, unsigned int treg
)
6579 int noreorder
= mips_opts
.noreorder
;
6582 gas_assert (mips_opts
.micromips
);
6586 micromips_label_expr (&expr1
);
6587 macro_build (&expr1
, brneg
, fmt
, sreg
, treg
);
6588 macro_build (NULL
, "nop", "");
6589 macro_build (ep
, call
? "bal" : "b", "p");
6591 /* Set to true so that append_insn adds a label. */
6592 emit_branch_likely_macro
= TRUE
;
6596 macro_build (ep
, br
, fmt
, sreg
, treg
);
6597 macro_build (NULL
, "nop", "");
6602 /* Emit a coprocessor branch-likely macro specified by TYPE, using CC as
6603 the condition code tested. EP specifies the branch target. */
6606 macro_build_branch_ccl (int type
, expressionS
*ep
, unsigned int cc
)
6633 macro_build_branch_likely (br
, brneg
, call
, ep
, "N,p", cc
, ZERO
);
6636 /* Emit a two-argument branch macro specified by TYPE, using SREG as
6637 the register tested. EP specifies the branch target. */
6640 macro_build_branch_rs (int type
, expressionS
*ep
, unsigned int sreg
)
6642 const char *brneg
= NULL
;
6652 br
= mips_opts
.micromips
? "bgez" : "bgezl";
6656 gas_assert (mips_opts
.micromips
);
6657 br
= mips_opts
.insn32
? "bgezal" : "bgezals";
6665 br
= mips_opts
.micromips
? "bgtz" : "bgtzl";
6672 br
= mips_opts
.micromips
? "blez" : "blezl";
6679 br
= mips_opts
.micromips
? "bltz" : "bltzl";
6683 gas_assert (mips_opts
.micromips
);
6684 br
= mips_opts
.insn32
? "bltzal" : "bltzals";
6691 if (mips_opts
.micromips
&& brneg
)
6692 macro_build_branch_likely (br
, brneg
, call
, ep
, "s,p", sreg
, ZERO
);
6694 macro_build (ep
, br
, "s,p", sreg
);
6697 /* Emit a three-argument branch macro specified by TYPE, using SREG and
6698 TREG as the registers tested. EP specifies the branch target. */
6701 macro_build_branch_rsrt (int type
, expressionS
*ep
,
6702 unsigned int sreg
, unsigned int treg
)
6704 const char *brneg
= NULL
;
6716 br
= mips_opts
.micromips
? "beq" : "beql";
6725 br
= mips_opts
.micromips
? "bne" : "bnel";
6731 if (mips_opts
.micromips
&& brneg
)
6732 macro_build_branch_likely (br
, brneg
, call
, ep
, "s,t,p", sreg
, treg
);
6734 macro_build (ep
, br
, "s,t,p", sreg
, treg
);
6739 * This routine implements the seemingly endless macro or synthesized
6740 * instructions and addressing modes in the mips assembly language. Many
6741 * of these macros are simple and are similar to each other. These could
6742 * probably be handled by some kind of table or grammar approach instead of
6743 * this verbose method. Others are not simple macros but are more like
6744 * optimizing code generation.
6745 * One interesting optimization is when several store macros appear
6746 * consecutively that would load AT with the upper half of the same address.
6747 * The ensuing load upper instructions are ommited. This implies some kind
6748 * of global optimization. We currently only optimize within a single macro.
6749 * For many of the load and store macros if the address is specified as a
6750 * constant expression in the first 64k of memory (ie ld $2,0x4000c) we
6751 * first load register 'at' with zero and use it as the base register. The
6752 * mips assembler simply uses register $zero. Just one tiny optimization
6756 macro (struct mips_cl_insn
*ip
, char *str
)
6758 unsigned int treg
, sreg
, dreg
, breg
;
6759 unsigned int tempreg
;
6762 expressionS label_expr
;
6779 bfd_reloc_code_real_type r
;
6780 int hold_mips_optimize
;
6782 gas_assert (! mips_opts
.mips16
);
6784 treg
= EXTRACT_OPERAND (mips_opts
.micromips
, RT
, *ip
);
6785 dreg
= EXTRACT_OPERAND (mips_opts
.micromips
, RD
, *ip
);
6786 sreg
= breg
= EXTRACT_OPERAND (mips_opts
.micromips
, RS
, *ip
);
6787 mask
= ip
->insn_mo
->mask
;
6789 label_expr
.X_op
= O_constant
;
6790 label_expr
.X_op_symbol
= NULL
;
6791 label_expr
.X_add_symbol
= NULL
;
6792 label_expr
.X_add_number
= 0;
6794 expr1
.X_op
= O_constant
;
6795 expr1
.X_op_symbol
= NULL
;
6796 expr1
.X_add_symbol
= NULL
;
6797 expr1
.X_add_number
= 1;
6812 if (mips_opts
.micromips
)
6813 micromips_label_expr (&label_expr
);
6815 label_expr
.X_add_number
= 8;
6816 macro_build (&label_expr
, "bgez", "s,p", sreg
);
6818 macro_build (NULL
, "nop", "");
6820 move_register (dreg
, sreg
);
6821 macro_build (NULL
, dbl
? "dsub" : "sub", "d,v,t", dreg
, 0, sreg
);
6822 if (mips_opts
.micromips
)
6823 micromips_add_label ();
6840 if (!mips_opts
.micromips
)
6842 if (imm_expr
.X_op
== O_constant
6843 && imm_expr
.X_add_number
>= -0x200
6844 && imm_expr
.X_add_number
< 0x200)
6846 macro_build (NULL
, s
, "t,r,.", treg
, sreg
, imm_expr
.X_add_number
);
6855 if (imm_expr
.X_op
== O_constant
6856 && imm_expr
.X_add_number
>= -0x8000
6857 && imm_expr
.X_add_number
< 0x8000)
6859 macro_build (&imm_expr
, s
, "t,r,j", treg
, sreg
, BFD_RELOC_LO16
);
6864 load_register (AT
, &imm_expr
, dbl
);
6865 macro_build (NULL
, s2
, "d,v,t", treg
, sreg
, AT
);
6884 if (imm_expr
.X_op
== O_constant
6885 && imm_expr
.X_add_number
>= 0
6886 && imm_expr
.X_add_number
< 0x10000)
6888 if (mask
!= M_NOR_I
)
6889 macro_build (&imm_expr
, s
, "t,r,i", treg
, sreg
, BFD_RELOC_LO16
);
6892 macro_build (&imm_expr
, "ori", "t,r,i",
6893 treg
, sreg
, BFD_RELOC_LO16
);
6894 macro_build (NULL
, "nor", "d,v,t", treg
, treg
, 0);
6900 load_register (AT
, &imm_expr
, HAVE_64BIT_GPRS
);
6901 macro_build (NULL
, s2
, "d,v,t", treg
, sreg
, AT
);
6905 switch (imm_expr
.X_add_number
)
6908 macro_build (NULL
, "nop", "");
6911 macro_build (NULL
, "packrl.ph", "d,s,t", treg
, treg
, sreg
);
6915 macro_build (NULL
, "balign", "t,s,2", treg
, sreg
,
6916 (int) imm_expr
.X_add_number
);
6919 as_bad (_("BALIGN immediate not 0, 1, 2 or 3 (%lu)"),
6920 (unsigned long) imm_expr
.X_add_number
);
6929 gas_assert (mips_opts
.micromips
);
6930 macro_build_branch_ccl (mask
, &offset_expr
,
6931 EXTRACT_OPERAND (1, BCC
, *ip
));
6938 if (imm_expr
.X_op
== O_constant
&& imm_expr
.X_add_number
== 0)
6944 load_register (treg
, &imm_expr
, HAVE_64BIT_GPRS
);
6949 macro_build_branch_rsrt (mask
, &offset_expr
, sreg
, treg
);
6956 macro_build_branch_rs (likely
? M_BGEZL
: M_BGEZ
, &offset_expr
, sreg
);
6958 macro_build_branch_rs (likely
? M_BLEZL
: M_BLEZ
, &offset_expr
, treg
);
6962 macro_build (NULL
, "slt", "d,v,t", AT
, sreg
, treg
);
6963 macro_build_branch_rsrt (likely
? M_BEQL
: M_BEQ
,
6964 &offset_expr
, AT
, ZERO
);
6974 macro_build_branch_rs (mask
, &offset_expr
, sreg
);
6980 /* Check for > max integer. */
6981 if (imm_expr
.X_op
== O_constant
&& imm_expr
.X_add_number
>= GPR_SMAX
)
6984 /* Result is always false. */
6986 macro_build (NULL
, "nop", "");
6988 macro_build_branch_rsrt (M_BNEL
, &offset_expr
, ZERO
, ZERO
);
6991 if (imm_expr
.X_op
!= O_constant
)
6992 as_bad (_("Unsupported large constant"));
6993 ++imm_expr
.X_add_number
;
6997 if (mask
== M_BGEL_I
)
6999 if (imm_expr
.X_op
== O_constant
&& imm_expr
.X_add_number
== 0)
7001 macro_build_branch_rs (likely
? M_BGEZL
: M_BGEZ
,
7002 &offset_expr
, sreg
);
7005 if (imm_expr
.X_op
== O_constant
&& imm_expr
.X_add_number
== 1)
7007 macro_build_branch_rs (likely
? M_BGTZL
: M_BGTZ
,
7008 &offset_expr
, sreg
);
7011 if (imm_expr
.X_op
== O_constant
&& imm_expr
.X_add_number
<= GPR_SMIN
)
7014 /* result is always true */
7015 as_warn (_("Branch %s is always true"), ip
->insn_mo
->name
);
7016 macro_build (&offset_expr
, "b", "p");
7021 macro_build_branch_rsrt (likely
? M_BEQL
: M_BEQ
,
7022 &offset_expr
, AT
, ZERO
);
7031 macro_build_branch_rsrt (likely
? M_BEQL
: M_BEQ
,
7032 &offset_expr
, ZERO
, treg
);
7036 macro_build (NULL
, "sltu", "d,v,t", AT
, sreg
, treg
);
7037 macro_build_branch_rsrt (likely
? M_BEQL
: M_BEQ
,
7038 &offset_expr
, AT
, ZERO
);
7047 && imm_expr
.X_op
== O_constant
7048 && imm_expr
.X_add_number
== -1))
7050 if (imm_expr
.X_op
!= O_constant
)
7051 as_bad (_("Unsupported large constant"));
7052 ++imm_expr
.X_add_number
;
7056 if (mask
== M_BGEUL_I
)
7058 if (imm_expr
.X_op
== O_constant
&& imm_expr
.X_add_number
== 0)
7060 else if (imm_expr
.X_op
== O_constant
&& imm_expr
.X_add_number
== 1)
7061 macro_build_branch_rsrt (likely
? M_BNEL
: M_BNE
,
7062 &offset_expr
, sreg
, ZERO
);
7067 macro_build_branch_rsrt (likely
? M_BEQL
: M_BEQ
,
7068 &offset_expr
, AT
, ZERO
);
7076 macro_build_branch_rs (likely
? M_BGTZL
: M_BGTZ
, &offset_expr
, sreg
);
7078 macro_build_branch_rs (likely
? M_BLTZL
: M_BLTZ
, &offset_expr
, treg
);
7082 macro_build (NULL
, "slt", "d,v,t", AT
, treg
, sreg
);
7083 macro_build_branch_rsrt (likely
? M_BNEL
: M_BNE
,
7084 &offset_expr
, AT
, ZERO
);
7092 macro_build_branch_rsrt (likely
? M_BNEL
: M_BNE
,
7093 &offset_expr
, sreg
, ZERO
);
7099 macro_build (NULL
, "sltu", "d,v,t", AT
, treg
, sreg
);
7100 macro_build_branch_rsrt (likely
? M_BNEL
: M_BNE
,
7101 &offset_expr
, AT
, ZERO
);
7109 macro_build_branch_rs (likely
? M_BLEZL
: M_BLEZ
, &offset_expr
, sreg
);
7111 macro_build_branch_rs (likely
? M_BGEZL
: M_BGEZ
, &offset_expr
, treg
);
7115 macro_build (NULL
, "slt", "d,v,t", AT
, treg
, sreg
);
7116 macro_build_branch_rsrt (likely
? M_BEQL
: M_BEQ
,
7117 &offset_expr
, AT
, ZERO
);
7124 if (imm_expr
.X_op
== O_constant
&& imm_expr
.X_add_number
>= GPR_SMAX
)
7126 if (imm_expr
.X_op
!= O_constant
)
7127 as_bad (_("Unsupported large constant"));
7128 ++imm_expr
.X_add_number
;
7132 if (mask
== M_BLTL_I
)
7134 if (imm_expr
.X_op
== O_constant
&& imm_expr
.X_add_number
== 0)
7135 macro_build_branch_rs (likely
? M_BLTZL
: M_BLTZ
, &offset_expr
, sreg
);
7136 else if (imm_expr
.X_op
== O_constant
&& imm_expr
.X_add_number
== 1)
7137 macro_build_branch_rs (likely
? M_BLEZL
: M_BLEZ
, &offset_expr
, sreg
);
7142 macro_build_branch_rsrt (likely
? M_BNEL
: M_BNE
,
7143 &offset_expr
, AT
, ZERO
);
7151 macro_build_branch_rsrt (likely
? M_BEQL
: M_BEQ
,
7152 &offset_expr
, sreg
, ZERO
);
7158 macro_build (NULL
, "sltu", "d,v,t", AT
, treg
, sreg
);
7159 macro_build_branch_rsrt (likely
? M_BEQL
: M_BEQ
,
7160 &offset_expr
, AT
, ZERO
);
7169 && imm_expr
.X_op
== O_constant
7170 && imm_expr
.X_add_number
== -1))
7172 if (imm_expr
.X_op
!= O_constant
)
7173 as_bad (_("Unsupported large constant"));
7174 ++imm_expr
.X_add_number
;
7178 if (mask
== M_BLTUL_I
)
7180 if (imm_expr
.X_op
== O_constant
&& imm_expr
.X_add_number
== 0)
7182 else if (imm_expr
.X_op
== O_constant
&& imm_expr
.X_add_number
== 1)
7183 macro_build_branch_rsrt (likely
? M_BEQL
: M_BEQ
,
7184 &offset_expr
, sreg
, ZERO
);
7189 macro_build_branch_rsrt (likely
? M_BNEL
: M_BNE
,
7190 &offset_expr
, AT
, ZERO
);
7198 macro_build_branch_rs (likely
? M_BLTZL
: M_BLTZ
, &offset_expr
, sreg
);
7200 macro_build_branch_rs (likely
? M_BGTZL
: M_BGTZ
, &offset_expr
, treg
);
7204 macro_build (NULL
, "slt", "d,v,t", AT
, sreg
, treg
);
7205 macro_build_branch_rsrt (likely
? M_BNEL
: M_BNE
,
7206 &offset_expr
, AT
, ZERO
);
7216 macro_build_branch_rsrt (likely
? M_BNEL
: M_BNE
,
7217 &offset_expr
, ZERO
, treg
);
7221 macro_build (NULL
, "sltu", "d,v,t", AT
, sreg
, treg
);
7222 macro_build_branch_rsrt (likely
? M_BNEL
: M_BNE
,
7223 &offset_expr
, AT
, ZERO
);
7229 /* Use unsigned arithmetic. */
7233 if (imm_expr
.X_op
!= O_constant
|| imm2_expr
.X_op
!= O_constant
)
7235 as_bad (_("Unsupported large constant"));
7240 pos
= imm_expr
.X_add_number
;
7241 size
= imm2_expr
.X_add_number
;
7246 as_bad (_("Improper position (%lu)"), (unsigned long) pos
);
7249 if (size
== 0 || size
> 64 || (pos
+ size
- 1) > 63)
7251 as_bad (_("Improper extract size (%lu, position %lu)"),
7252 (unsigned long) size
, (unsigned long) pos
);
7256 if (size
<= 32 && pos
< 32)
7261 else if (size
<= 32)
7271 macro_build ((expressionS
*) NULL
, s
, fmt
, treg
, sreg
, (int) pos
,
7278 /* Use unsigned arithmetic. */
7282 if (imm_expr
.X_op
!= O_constant
|| imm2_expr
.X_op
!= O_constant
)
7284 as_bad (_("Unsupported large constant"));
7289 pos
= imm_expr
.X_add_number
;
7290 size
= imm2_expr
.X_add_number
;
7295 as_bad (_("Improper position (%lu)"), (unsigned long) pos
);
7298 if (size
== 0 || size
> 64 || (pos
+ size
- 1) > 63)
7300 as_bad (_("Improper insert size (%lu, position %lu)"),
7301 (unsigned long) size
, (unsigned long) pos
);
7305 if (pos
< 32 && (pos
+ size
- 1) < 32)
7320 macro_build ((expressionS
*) NULL
, s
, fmt
, treg
, sreg
, (int) pos
,
7321 (int) (pos
+ size
- 1));
7337 as_warn (_("Divide by zero."));
7339 macro_build (NULL
, "teq", TRAP_FMT
, ZERO
, ZERO
, 7);
7341 macro_build (NULL
, "break", BRK_FMT
, 7);
7348 macro_build (NULL
, "teq", TRAP_FMT
, treg
, ZERO
, 7);
7349 macro_build (NULL
, dbl
? "ddiv" : "div", "z,s,t", sreg
, treg
);
7353 if (mips_opts
.micromips
)
7354 micromips_label_expr (&label_expr
);
7356 label_expr
.X_add_number
= 8;
7357 macro_build (&label_expr
, "bne", "s,t,p", treg
, ZERO
);
7358 macro_build (NULL
, dbl
? "ddiv" : "div", "z,s,t", sreg
, treg
);
7359 macro_build (NULL
, "break", BRK_FMT
, 7);
7360 if (mips_opts
.micromips
)
7361 micromips_add_label ();
7363 expr1
.X_add_number
= -1;
7365 load_register (AT
, &expr1
, dbl
);
7366 if (mips_opts
.micromips
)
7367 micromips_label_expr (&label_expr
);
7369 label_expr
.X_add_number
= mips_trap
? (dbl
? 12 : 8) : (dbl
? 20 : 16);
7370 macro_build (&label_expr
, "bne", "s,t,p", treg
, AT
);
7373 expr1
.X_add_number
= 1;
7374 load_register (AT
, &expr1
, dbl
);
7375 macro_build (NULL
, "dsll32", SHFT_FMT
, AT
, AT
, 31);
7379 expr1
.X_add_number
= 0x80000000;
7380 macro_build (&expr1
, "lui", LUI_FMT
, AT
, BFD_RELOC_HI16
);
7384 macro_build (NULL
, "teq", TRAP_FMT
, sreg
, AT
, 6);
7385 /* We want to close the noreorder block as soon as possible, so
7386 that later insns are available for delay slot filling. */
7391 if (mips_opts
.micromips
)
7392 micromips_label_expr (&label_expr
);
7394 label_expr
.X_add_number
= 8;
7395 macro_build (&label_expr
, "bne", "s,t,p", sreg
, AT
);
7396 macro_build (NULL
, "nop", "");
7398 /* We want to close the noreorder block as soon as possible, so
7399 that later insns are available for delay slot filling. */
7402 macro_build (NULL
, "break", BRK_FMT
, 6);
7404 if (mips_opts
.micromips
)
7405 micromips_add_label ();
7406 macro_build (NULL
, s
, MFHL_FMT
, dreg
);
7445 if (imm_expr
.X_op
== O_constant
&& imm_expr
.X_add_number
== 0)
7447 as_warn (_("Divide by zero."));
7449 macro_build (NULL
, "teq", TRAP_FMT
, ZERO
, ZERO
, 7);
7451 macro_build (NULL
, "break", BRK_FMT
, 7);
7454 if (imm_expr
.X_op
== O_constant
&& imm_expr
.X_add_number
== 1)
7456 if (strcmp (s2
, "mflo") == 0)
7457 move_register (dreg
, sreg
);
7459 move_register (dreg
, ZERO
);
7462 if (imm_expr
.X_op
== O_constant
7463 && imm_expr
.X_add_number
== -1
7464 && s
[strlen (s
) - 1] != 'u')
7466 if (strcmp (s2
, "mflo") == 0)
7468 macro_build (NULL
, dbl
? "dneg" : "neg", "d,w", dreg
, sreg
);
7471 move_register (dreg
, ZERO
);
7476 load_register (AT
, &imm_expr
, dbl
);
7477 macro_build (NULL
, s
, "z,s,t", sreg
, AT
);
7478 macro_build (NULL
, s2
, MFHL_FMT
, dreg
);
7500 macro_build (NULL
, "teq", TRAP_FMT
, treg
, ZERO
, 7);
7501 macro_build (NULL
, s
, "z,s,t", sreg
, treg
);
7502 /* We want to close the noreorder block as soon as possible, so
7503 that later insns are available for delay slot filling. */
7508 if (mips_opts
.micromips
)
7509 micromips_label_expr (&label_expr
);
7511 label_expr
.X_add_number
= 8;
7512 macro_build (&label_expr
, "bne", "s,t,p", treg
, ZERO
);
7513 macro_build (NULL
, s
, "z,s,t", sreg
, treg
);
7515 /* We want to close the noreorder block as soon as possible, so
7516 that later insns are available for delay slot filling. */
7518 macro_build (NULL
, "break", BRK_FMT
, 7);
7519 if (mips_opts
.micromips
)
7520 micromips_add_label ();
7522 macro_build (NULL
, s2
, MFHL_FMT
, dreg
);
7534 /* Load the address of a symbol into a register. If breg is not
7535 zero, we then add a base register to it. */
7537 if (dbl
&& HAVE_32BIT_GPRS
)
7538 as_warn (_("dla used to load 32-bit register"));
7540 if (!dbl
&& HAVE_64BIT_OBJECTS
)
7541 as_warn (_("la used to load 64-bit address"));
7543 if (offset_expr
.X_op
== O_constant
7544 && offset_expr
.X_add_number
>= -0x8000
7545 && offset_expr
.X_add_number
< 0x8000)
7547 macro_build (&offset_expr
, ADDRESS_ADDI_INSN
,
7548 "t,r,j", treg
, sreg
, BFD_RELOC_LO16
);
7552 if (mips_opts
.at
&& (treg
== breg
))
7562 if (offset_expr
.X_op
!= O_symbol
7563 && offset_expr
.X_op
!= O_constant
)
7565 as_bad (_("Expression too complex"));
7566 offset_expr
.X_op
= O_constant
;
7569 if (offset_expr
.X_op
== O_constant
)
7570 load_register (tempreg
, &offset_expr
, HAVE_64BIT_ADDRESSES
);
7571 else if (mips_pic
== NO_PIC
)
7573 /* If this is a reference to a GP relative symbol, we want
7574 addiu $tempreg,$gp,<sym> (BFD_RELOC_GPREL16)
7576 lui $tempreg,<sym> (BFD_RELOC_HI16_S)
7577 addiu $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
7578 If we have a constant, we need two instructions anyhow,
7579 so we may as well always use the latter form.
7581 With 64bit address space and a usable $at we want
7582 lui $tempreg,<sym> (BFD_RELOC_MIPS_HIGHEST)
7583 lui $at,<sym> (BFD_RELOC_HI16_S)
7584 daddiu $tempreg,<sym> (BFD_RELOC_MIPS_HIGHER)
7585 daddiu $at,<sym> (BFD_RELOC_LO16)
7587 daddu $tempreg,$tempreg,$at
7589 If $at is already in use, we use a path which is suboptimal
7590 on superscalar processors.
7591 lui $tempreg,<sym> (BFD_RELOC_MIPS_HIGHEST)
7592 daddiu $tempreg,<sym> (BFD_RELOC_MIPS_HIGHER)
7594 daddiu $tempreg,<sym> (BFD_RELOC_HI16_S)
7596 daddiu $tempreg,<sym> (BFD_RELOC_LO16)
7598 For GP relative symbols in 64bit address space we can use
7599 the same sequence as in 32bit address space. */
7600 if (HAVE_64BIT_SYMBOLS
)
7602 if ((valueT
) offset_expr
.X_add_number
<= MAX_GPREL_OFFSET
7603 && !nopic_need_relax (offset_expr
.X_add_symbol
, 1))
7605 relax_start (offset_expr
.X_add_symbol
);
7606 macro_build (&offset_expr
, ADDRESS_ADDI_INSN
, "t,r,j",
7607 tempreg
, mips_gp_register
, BFD_RELOC_GPREL16
);
7611 if (used_at
== 0 && mips_opts
.at
)
7613 macro_build (&offset_expr
, "lui", LUI_FMT
,
7614 tempreg
, BFD_RELOC_MIPS_HIGHEST
);
7615 macro_build (&offset_expr
, "lui", LUI_FMT
,
7616 AT
, BFD_RELOC_HI16_S
);
7617 macro_build (&offset_expr
, "daddiu", "t,r,j",
7618 tempreg
, tempreg
, BFD_RELOC_MIPS_HIGHER
);
7619 macro_build (&offset_expr
, "daddiu", "t,r,j",
7620 AT
, AT
, BFD_RELOC_LO16
);
7621 macro_build (NULL
, "dsll32", SHFT_FMT
, tempreg
, tempreg
, 0);
7622 macro_build (NULL
, "daddu", "d,v,t", tempreg
, tempreg
, AT
);
7627 macro_build (&offset_expr
, "lui", LUI_FMT
,
7628 tempreg
, BFD_RELOC_MIPS_HIGHEST
);
7629 macro_build (&offset_expr
, "daddiu", "t,r,j",
7630 tempreg
, tempreg
, BFD_RELOC_MIPS_HIGHER
);
7631 macro_build (NULL
, "dsll", SHFT_FMT
, tempreg
, tempreg
, 16);
7632 macro_build (&offset_expr
, "daddiu", "t,r,j",
7633 tempreg
, tempreg
, BFD_RELOC_HI16_S
);
7634 macro_build (NULL
, "dsll", SHFT_FMT
, tempreg
, tempreg
, 16);
7635 macro_build (&offset_expr
, "daddiu", "t,r,j",
7636 tempreg
, tempreg
, BFD_RELOC_LO16
);
7639 if (mips_relax
.sequence
)
7644 if ((valueT
) offset_expr
.X_add_number
<= MAX_GPREL_OFFSET
7645 && !nopic_need_relax (offset_expr
.X_add_symbol
, 1))
7647 relax_start (offset_expr
.X_add_symbol
);
7648 macro_build (&offset_expr
, ADDRESS_ADDI_INSN
, "t,r,j",
7649 tempreg
, mips_gp_register
, BFD_RELOC_GPREL16
);
7652 if (!IS_SEXT_32BIT_NUM (offset_expr
.X_add_number
))
7653 as_bad (_("Offset too large"));
7654 macro_build_lui (&offset_expr
, tempreg
);
7655 macro_build (&offset_expr
, ADDRESS_ADDI_INSN
, "t,r,j",
7656 tempreg
, tempreg
, BFD_RELOC_LO16
);
7657 if (mips_relax
.sequence
)
7661 else if (!mips_big_got
&& !HAVE_NEWABI
)
7663 int lw_reloc_type
= (int) BFD_RELOC_MIPS_GOT16
;
7665 /* If this is a reference to an external symbol, and there
7666 is no constant, we want
7667 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
7668 or for lca or if tempreg is PIC_CALL_REG
7669 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_CALL16)
7670 For a local symbol, we want
7671 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
7673 addiu $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
7675 If we have a small constant, and this is a reference to
7676 an external symbol, we want
7677 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
7679 addiu $tempreg,$tempreg,<constant>
7680 For a local symbol, we want the same instruction
7681 sequence, but we output a BFD_RELOC_LO16 reloc on the
7684 If we have a large constant, and this is a reference to
7685 an external symbol, we want
7686 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
7687 lui $at,<hiconstant>
7688 addiu $at,$at,<loconstant>
7689 addu $tempreg,$tempreg,$at
7690 For a local symbol, we want the same instruction
7691 sequence, but we output a BFD_RELOC_LO16 reloc on the
7695 if (offset_expr
.X_add_number
== 0)
7697 if (mips_pic
== SVR4_PIC
7699 && (call
|| tempreg
== PIC_CALL_REG
))
7700 lw_reloc_type
= (int) BFD_RELOC_MIPS_CALL16
;
7702 relax_start (offset_expr
.X_add_symbol
);
7703 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", tempreg
,
7704 lw_reloc_type
, mips_gp_register
);
7707 /* We're going to put in an addu instruction using
7708 tempreg, so we may as well insert the nop right
7713 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)",
7714 tempreg
, BFD_RELOC_MIPS_GOT16
, mips_gp_register
);
7716 macro_build (&offset_expr
, ADDRESS_ADDI_INSN
, "t,r,j",
7717 tempreg
, tempreg
, BFD_RELOC_LO16
);
7719 /* FIXME: If breg == 0, and the next instruction uses
7720 $tempreg, then if this variant case is used an extra
7721 nop will be generated. */
7723 else if (offset_expr
.X_add_number
>= -0x8000
7724 && offset_expr
.X_add_number
< 0x8000)
7726 load_got_offset (tempreg
, &offset_expr
);
7728 add_got_offset (tempreg
, &offset_expr
);
7732 expr1
.X_add_number
= offset_expr
.X_add_number
;
7733 offset_expr
.X_add_number
=
7734 SEXT_16BIT (offset_expr
.X_add_number
);
7735 load_got_offset (tempreg
, &offset_expr
);
7736 offset_expr
.X_add_number
= expr1
.X_add_number
;
7737 /* If we are going to add in a base register, and the
7738 target register and the base register are the same,
7739 then we are using AT as a temporary register. Since
7740 we want to load the constant into AT, we add our
7741 current AT (from the global offset table) and the
7742 register into the register now, and pretend we were
7743 not using a base register. */
7747 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
7752 add_got_offset_hilo (tempreg
, &offset_expr
, AT
);
7756 else if (!mips_big_got
&& HAVE_NEWABI
)
7758 int add_breg_early
= 0;
7760 /* If this is a reference to an external, and there is no
7761 constant, or local symbol (*), with or without a
7763 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT_DISP)
7764 or for lca or if tempreg is PIC_CALL_REG
7765 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_CALL16)
7767 If we have a small constant, and this is a reference to
7768 an external symbol, we want
7769 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT_DISP)
7770 addiu $tempreg,$tempreg,<constant>
7772 If we have a large constant, and this is a reference to
7773 an external symbol, we want
7774 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT_DISP)
7775 lui $at,<hiconstant>
7776 addiu $at,$at,<loconstant>
7777 addu $tempreg,$tempreg,$at
7779 (*) Other assemblers seem to prefer GOT_PAGE/GOT_OFST for
7780 local symbols, even though it introduces an additional
7783 if (offset_expr
.X_add_number
)
7785 expr1
.X_add_number
= offset_expr
.X_add_number
;
7786 offset_expr
.X_add_number
= 0;
7788 relax_start (offset_expr
.X_add_symbol
);
7789 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", tempreg
,
7790 BFD_RELOC_MIPS_GOT_DISP
, mips_gp_register
);
7792 if (expr1
.X_add_number
>= -0x8000
7793 && expr1
.X_add_number
< 0x8000)
7795 macro_build (&expr1
, ADDRESS_ADDI_INSN
, "t,r,j",
7796 tempreg
, tempreg
, BFD_RELOC_LO16
);
7798 else if (IS_SEXT_32BIT_NUM (expr1
.X_add_number
+ 0x8000))
7800 /* If we are going to add in a base register, and the
7801 target register and the base register are the same,
7802 then we are using AT as a temporary register. Since
7803 we want to load the constant into AT, we add our
7804 current AT (from the global offset table) and the
7805 register into the register now, and pretend we were
7806 not using a base register. */
7811 gas_assert (tempreg
== AT
);
7812 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
7818 load_register (AT
, &expr1
, HAVE_64BIT_ADDRESSES
);
7819 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
7825 as_bad (_("PIC code offset overflow (max 32 signed bits)"));
7828 offset_expr
.X_add_number
= expr1
.X_add_number
;
7830 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", tempreg
,
7831 BFD_RELOC_MIPS_GOT_DISP
, mips_gp_register
);
7834 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
7835 treg
, tempreg
, breg
);
7841 else if (breg
== 0 && (call
|| tempreg
== PIC_CALL_REG
))
7843 relax_start (offset_expr
.X_add_symbol
);
7844 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", tempreg
,
7845 BFD_RELOC_MIPS_CALL16
, mips_gp_register
);
7847 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", tempreg
,
7848 BFD_RELOC_MIPS_GOT_DISP
, mips_gp_register
);
7853 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", tempreg
,
7854 BFD_RELOC_MIPS_GOT_DISP
, mips_gp_register
);
7857 else if (mips_big_got
&& !HAVE_NEWABI
)
7860 int lui_reloc_type
= (int) BFD_RELOC_MIPS_GOT_HI16
;
7861 int lw_reloc_type
= (int) BFD_RELOC_MIPS_GOT_LO16
;
7862 int local_reloc_type
= (int) BFD_RELOC_MIPS_GOT16
;
7864 /* This is the large GOT case. If this is a reference to an
7865 external symbol, and there is no constant, we want
7866 lui $tempreg,<sym> (BFD_RELOC_MIPS_GOT_HI16)
7867 addu $tempreg,$tempreg,$gp
7868 lw $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
7869 or for lca or if tempreg is PIC_CALL_REG
7870 lui $tempreg,<sym> (BFD_RELOC_MIPS_CALL_HI16)
7871 addu $tempreg,$tempreg,$gp
7872 lw $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_CALL_LO16)
7873 For a local symbol, we want
7874 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
7876 addiu $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
7878 If we have a small constant, and this is a reference to
7879 an external symbol, we want
7880 lui $tempreg,<sym> (BFD_RELOC_MIPS_GOT_HI16)
7881 addu $tempreg,$tempreg,$gp
7882 lw $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
7884 addiu $tempreg,$tempreg,<constant>
7885 For a local symbol, we want
7886 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
7888 addiu $tempreg,$tempreg,<constant> (BFD_RELOC_LO16)
7890 If we have a large constant, and this is a reference to
7891 an external symbol, we want
7892 lui $tempreg,<sym> (BFD_RELOC_MIPS_GOT_HI16)
7893 addu $tempreg,$tempreg,$gp
7894 lw $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
7895 lui $at,<hiconstant>
7896 addiu $at,$at,<loconstant>
7897 addu $tempreg,$tempreg,$at
7898 For a local symbol, we want
7899 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
7900 lui $at,<hiconstant>
7901 addiu $at,$at,<loconstant> (BFD_RELOC_LO16)
7902 addu $tempreg,$tempreg,$at
7905 expr1
.X_add_number
= offset_expr
.X_add_number
;
7906 offset_expr
.X_add_number
= 0;
7907 relax_start (offset_expr
.X_add_symbol
);
7908 gpdelay
= reg_needs_delay (mips_gp_register
);
7909 if (expr1
.X_add_number
== 0 && breg
== 0
7910 && (call
|| tempreg
== PIC_CALL_REG
))
7912 lui_reloc_type
= (int) BFD_RELOC_MIPS_CALL_HI16
;
7913 lw_reloc_type
= (int) BFD_RELOC_MIPS_CALL_LO16
;
7915 macro_build (&offset_expr
, "lui", LUI_FMT
, tempreg
, lui_reloc_type
);
7916 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
7917 tempreg
, tempreg
, mips_gp_register
);
7918 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)",
7919 tempreg
, lw_reloc_type
, tempreg
);
7920 if (expr1
.X_add_number
== 0)
7924 /* We're going to put in an addu instruction using
7925 tempreg, so we may as well insert the nop right
7930 else if (expr1
.X_add_number
>= -0x8000
7931 && expr1
.X_add_number
< 0x8000)
7934 macro_build (&expr1
, ADDRESS_ADDI_INSN
, "t,r,j",
7935 tempreg
, tempreg
, BFD_RELOC_LO16
);
7939 /* If we are going to add in a base register, and the
7940 target register and the base register are the same,
7941 then we are using AT as a temporary register. Since
7942 we want to load the constant into AT, we add our
7943 current AT (from the global offset table) and the
7944 register into the register now, and pretend we were
7945 not using a base register. */
7950 gas_assert (tempreg
== AT
);
7952 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
7957 load_register (AT
, &expr1
, HAVE_64BIT_ADDRESSES
);
7958 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t", dreg
, dreg
, AT
);
7962 offset_expr
.X_add_number
= SEXT_16BIT (expr1
.X_add_number
);
7967 /* This is needed because this instruction uses $gp, but
7968 the first instruction on the main stream does not. */
7969 macro_build (NULL
, "nop", "");
7972 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", tempreg
,
7973 local_reloc_type
, mips_gp_register
);
7974 if (expr1
.X_add_number
>= -0x8000
7975 && expr1
.X_add_number
< 0x8000)
7978 macro_build (&offset_expr
, ADDRESS_ADDI_INSN
, "t,r,j",
7979 tempreg
, tempreg
, BFD_RELOC_LO16
);
7980 /* FIXME: If add_number is 0, and there was no base
7981 register, the external symbol case ended with a load,
7982 so if the symbol turns out to not be external, and
7983 the next instruction uses tempreg, an unnecessary nop
7984 will be inserted. */
7990 /* We must add in the base register now, as in the
7991 external symbol case. */
7992 gas_assert (tempreg
== AT
);
7994 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
7997 /* We set breg to 0 because we have arranged to add
7998 it in in both cases. */
8002 macro_build_lui (&expr1
, AT
);
8003 macro_build (&offset_expr
, ADDRESS_ADDI_INSN
, "t,r,j",
8004 AT
, AT
, BFD_RELOC_LO16
);
8005 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
8006 tempreg
, tempreg
, AT
);
8011 else if (mips_big_got
&& HAVE_NEWABI
)
8013 int lui_reloc_type
= (int) BFD_RELOC_MIPS_GOT_HI16
;
8014 int lw_reloc_type
= (int) BFD_RELOC_MIPS_GOT_LO16
;
8015 int add_breg_early
= 0;
8017 /* This is the large GOT case. If this is a reference to an
8018 external symbol, and there is no constant, we want
8019 lui $tempreg,<sym> (BFD_RELOC_MIPS_GOT_HI16)
8020 add $tempreg,$tempreg,$gp
8021 lw $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
8022 or for lca or if tempreg is PIC_CALL_REG
8023 lui $tempreg,<sym> (BFD_RELOC_MIPS_CALL_HI16)
8024 add $tempreg,$tempreg,$gp
8025 lw $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_CALL_LO16)
8027 If we have a small constant, and this is a reference to
8028 an external symbol, we want
8029 lui $tempreg,<sym> (BFD_RELOC_MIPS_GOT_HI16)
8030 add $tempreg,$tempreg,$gp
8031 lw $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
8032 addi $tempreg,$tempreg,<constant>
8034 If we have a large constant, and this is a reference to
8035 an external symbol, we want
8036 lui $tempreg,<sym> (BFD_RELOC_MIPS_GOT_HI16)
8037 addu $tempreg,$tempreg,$gp
8038 lw $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
8039 lui $at,<hiconstant>
8040 addi $at,$at,<loconstant>
8041 add $tempreg,$tempreg,$at
8043 If we have NewABI, and we know it's a local symbol, we want
8044 lw $reg,<sym>($gp) (BFD_RELOC_MIPS_GOT_PAGE)
8045 addiu $reg,$reg,<sym> (BFD_RELOC_MIPS_GOT_OFST)
8046 otherwise we have to resort to GOT_HI16/GOT_LO16. */
8048 relax_start (offset_expr
.X_add_symbol
);
8050 expr1
.X_add_number
= offset_expr
.X_add_number
;
8051 offset_expr
.X_add_number
= 0;
8053 if (expr1
.X_add_number
== 0 && breg
== 0
8054 && (call
|| tempreg
== PIC_CALL_REG
))
8056 lui_reloc_type
= (int) BFD_RELOC_MIPS_CALL_HI16
;
8057 lw_reloc_type
= (int) BFD_RELOC_MIPS_CALL_LO16
;
8059 macro_build (&offset_expr
, "lui", LUI_FMT
, tempreg
, lui_reloc_type
);
8060 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
8061 tempreg
, tempreg
, mips_gp_register
);
8062 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)",
8063 tempreg
, lw_reloc_type
, tempreg
);
8065 if (expr1
.X_add_number
== 0)
8067 else if (expr1
.X_add_number
>= -0x8000
8068 && expr1
.X_add_number
< 0x8000)
8070 macro_build (&expr1
, ADDRESS_ADDI_INSN
, "t,r,j",
8071 tempreg
, tempreg
, BFD_RELOC_LO16
);
8073 else if (IS_SEXT_32BIT_NUM (expr1
.X_add_number
+ 0x8000))
8075 /* If we are going to add in a base register, and the
8076 target register and the base register are the same,
8077 then we are using AT as a temporary register. Since
8078 we want to load the constant into AT, we add our
8079 current AT (from the global offset table) and the
8080 register into the register now, and pretend we were
8081 not using a base register. */
8086 gas_assert (tempreg
== AT
);
8087 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
8093 load_register (AT
, &expr1
, HAVE_64BIT_ADDRESSES
);
8094 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t", dreg
, dreg
, AT
);
8099 as_bad (_("PIC code offset overflow (max 32 signed bits)"));
8102 offset_expr
.X_add_number
= expr1
.X_add_number
;
8103 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", tempreg
,
8104 BFD_RELOC_MIPS_GOT_PAGE
, mips_gp_register
);
8105 macro_build (&offset_expr
, ADDRESS_ADDI_INSN
, "t,r,j", tempreg
,
8106 tempreg
, BFD_RELOC_MIPS_GOT_OFST
);
8109 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
8110 treg
, tempreg
, breg
);
8120 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t", treg
, tempreg
, breg
);
8124 gas_assert (!mips_opts
.micromips
);
8126 unsigned long temp
= (treg
<< 16) | (0x01);
8127 macro_build (NULL
, "c2", "C", temp
);
8132 gas_assert (!mips_opts
.micromips
);
8134 unsigned long temp
= (0x02);
8135 macro_build (NULL
, "c2", "C", temp
);
8140 gas_assert (!mips_opts
.micromips
);
8142 unsigned long temp
= (treg
<< 16) | (0x02);
8143 macro_build (NULL
, "c2", "C", temp
);
8148 gas_assert (!mips_opts
.micromips
);
8149 macro_build (NULL
, "c2", "C", 3);
8153 gas_assert (!mips_opts
.micromips
);
8155 unsigned long temp
= (treg
<< 16) | 0x03;
8156 macro_build (NULL
, "c2", "C", temp
);
8161 /* The j instruction may not be used in PIC code, since it
8162 requires an absolute address. We convert it to a b
8164 if (mips_pic
== NO_PIC
)
8165 macro_build (&offset_expr
, "j", "a");
8167 macro_build (&offset_expr
, "b", "p");
8170 /* The jal instructions must be handled as macros because when
8171 generating PIC code they expand to multi-instruction
8172 sequences. Normally they are simple instructions. */
8177 gas_assert (mips_opts
.micromips
);
8178 if (mips_opts
.insn32
)
8180 as_bad (_("Opcode not supported in the `insn32' mode `%s'"), str
);
8190 if (mips_pic
== NO_PIC
)
8192 s
= jals
? "jalrs" : "jalr";
8193 if (mips_opts
.micromips
8194 && !mips_opts
.insn32
8196 && !(history
[0].insn_mo
->pinfo2
& INSN2_BRANCH_DELAY_32BIT
))
8197 macro_build (NULL
, s
, "mj", sreg
);
8199 macro_build (NULL
, s
, JALR_FMT
, dreg
, sreg
);
8203 int cprestore
= (mips_pic
== SVR4_PIC
&& !HAVE_NEWABI
8204 && mips_cprestore_offset
>= 0);
8206 if (sreg
!= PIC_CALL_REG
)
8207 as_warn (_("MIPS PIC call to register other than $25"));
8209 s
= ((mips_opts
.micromips
8210 && !mips_opts
.insn32
8211 && (!mips_opts
.noreorder
|| cprestore
))
8212 ? "jalrs" : "jalr");
8213 if (mips_opts
.micromips
8214 && !mips_opts
.insn32
8216 && !(history
[0].insn_mo
->pinfo2
& INSN2_BRANCH_DELAY_32BIT
))
8217 macro_build (NULL
, s
, "mj", sreg
);
8219 macro_build (NULL
, s
, JALR_FMT
, dreg
, sreg
);
8220 if (mips_pic
== SVR4_PIC
&& !HAVE_NEWABI
)
8222 if (mips_cprestore_offset
< 0)
8223 as_warn (_("No .cprestore pseudo-op used in PIC code"));
8226 if (!mips_frame_reg_valid
)
8228 as_warn (_("No .frame pseudo-op used in PIC code"));
8229 /* Quiet this warning. */
8230 mips_frame_reg_valid
= 1;
8232 if (!mips_cprestore_valid
)
8234 as_warn (_("No .cprestore pseudo-op used in PIC code"));
8235 /* Quiet this warning. */
8236 mips_cprestore_valid
= 1;
8238 if (mips_opts
.noreorder
)
8239 macro_build (NULL
, "nop", "");
8240 expr1
.X_add_number
= mips_cprestore_offset
;
8241 macro_build_ldst_constoffset (&expr1
, ADDRESS_LOAD_INSN
,
8244 HAVE_64BIT_ADDRESSES
);
8252 gas_assert (mips_opts
.micromips
);
8253 if (mips_opts
.insn32
)
8255 as_bad (_("Opcode not supported in the `insn32' mode `%s'"), str
);
8261 if (mips_pic
== NO_PIC
)
8262 macro_build (&offset_expr
, jals
? "jals" : "jal", "a");
8263 else if (mips_pic
== SVR4_PIC
)
8265 /* If this is a reference to an external symbol, and we are
8266 using a small GOT, we want
8267 lw $25,<sym>($gp) (BFD_RELOC_MIPS_CALL16)
8271 lw $gp,cprestore($sp)
8272 The cprestore value is set using the .cprestore
8273 pseudo-op. If we are using a big GOT, we want
8274 lui $25,<sym> (BFD_RELOC_MIPS_CALL_HI16)
8276 lw $25,<sym>($25) (BFD_RELOC_MIPS_CALL_LO16)
8280 lw $gp,cprestore($sp)
8281 If the symbol is not external, we want
8282 lw $25,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
8284 addiu $25,$25,<sym> (BFD_RELOC_LO16)
8287 lw $gp,cprestore($sp)
8289 For NewABI, we use the same CALL16 or CALL_HI16/CALL_LO16
8290 sequences above, minus nops, unless the symbol is local,
8291 which enables us to use GOT_PAGE/GOT_OFST (big got) or
8297 relax_start (offset_expr
.X_add_symbol
);
8298 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)",
8299 PIC_CALL_REG
, BFD_RELOC_MIPS_CALL16
,
8302 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)",
8303 PIC_CALL_REG
, BFD_RELOC_MIPS_GOT_DISP
,
8309 relax_start (offset_expr
.X_add_symbol
);
8310 macro_build (&offset_expr
, "lui", LUI_FMT
, PIC_CALL_REG
,
8311 BFD_RELOC_MIPS_CALL_HI16
);
8312 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t", PIC_CALL_REG
,
8313 PIC_CALL_REG
, mips_gp_register
);
8314 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)",
8315 PIC_CALL_REG
, BFD_RELOC_MIPS_CALL_LO16
,
8318 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)",
8319 PIC_CALL_REG
, BFD_RELOC_MIPS_GOT_PAGE
,
8321 macro_build (&offset_expr
, ADDRESS_ADDI_INSN
, "t,r,j",
8322 PIC_CALL_REG
, PIC_CALL_REG
,
8323 BFD_RELOC_MIPS_GOT_OFST
);
8327 macro_build_jalr (&offset_expr
, 0);
8331 relax_start (offset_expr
.X_add_symbol
);
8334 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)",
8335 PIC_CALL_REG
, BFD_RELOC_MIPS_CALL16
,
8344 gpdelay
= reg_needs_delay (mips_gp_register
);
8345 macro_build (&offset_expr
, "lui", LUI_FMT
, PIC_CALL_REG
,
8346 BFD_RELOC_MIPS_CALL_HI16
);
8347 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t", PIC_CALL_REG
,
8348 PIC_CALL_REG
, mips_gp_register
);
8349 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)",
8350 PIC_CALL_REG
, BFD_RELOC_MIPS_CALL_LO16
,
8355 macro_build (NULL
, "nop", "");
8357 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)",
8358 PIC_CALL_REG
, BFD_RELOC_MIPS_GOT16
,
8361 macro_build (&offset_expr
, ADDRESS_ADDI_INSN
, "t,r,j",
8362 PIC_CALL_REG
, PIC_CALL_REG
, BFD_RELOC_LO16
);
8364 macro_build_jalr (&offset_expr
, mips_cprestore_offset
>= 0);
8366 if (mips_cprestore_offset
< 0)
8367 as_warn (_("No .cprestore pseudo-op used in PIC code"));
8370 if (!mips_frame_reg_valid
)
8372 as_warn (_("No .frame pseudo-op used in PIC code"));
8373 /* Quiet this warning. */
8374 mips_frame_reg_valid
= 1;
8376 if (!mips_cprestore_valid
)
8378 as_warn (_("No .cprestore pseudo-op used in PIC code"));
8379 /* Quiet this warning. */
8380 mips_cprestore_valid
= 1;
8382 if (mips_opts
.noreorder
)
8383 macro_build (NULL
, "nop", "");
8384 expr1
.X_add_number
= mips_cprestore_offset
;
8385 macro_build_ldst_constoffset (&expr1
, ADDRESS_LOAD_INSN
,
8388 HAVE_64BIT_ADDRESSES
);
8392 else if (mips_pic
== VXWORKS_PIC
)
8393 as_bad (_("Non-PIC jump used in PIC library"));
8501 treg
= EXTRACT_OPERAND (mips_opts
.micromips
, 3BITPOS
, *ip
);
8509 treg
= EXTRACT_OPERAND (mips_opts
.micromips
, 3BITPOS
, *ip
);
8540 gas_assert (!mips_opts
.micromips
);
8543 /* Itbl support may require additional care here. */
8550 /* Itbl support may require additional care here. */
8558 offbits
= (mips_opts
.micromips
? 12 : 16);
8559 /* Itbl support may require additional care here. */
8564 gas_assert (!mips_opts
.micromips
);
8567 /* Itbl support may require additional care here. */
8575 offbits
= (mips_opts
.micromips
? 12 : 16);
8582 offbits
= (mips_opts
.micromips
? 12 : 16);
8588 /* Itbl support may require additional care here. */
8596 offbits
= (mips_opts
.micromips
? 12 : 16);
8597 /* Itbl support may require additional care here. */
8604 /* Itbl support may require additional care here. */
8611 /* Itbl support may require additional care here. */
8619 offbits
= (mips_opts
.micromips
? 12 : 16);
8626 offbits
= (mips_opts
.micromips
? 12 : 16);
8633 offbits
= (mips_opts
.micromips
? 12 : 16);
8640 offbits
= (mips_opts
.micromips
? 12 : 16);
8647 offbits
= (mips_opts
.micromips
? 12 : 16);
8652 gas_assert (mips_opts
.micromips
);
8661 gas_assert (mips_opts
.micromips
);
8670 gas_assert (mips_opts
.micromips
);
8678 gas_assert (mips_opts
.micromips
);
8685 /* We don't want to use $0 as tempreg. */
8686 if (breg
== treg
+ lp
|| treg
+ lp
== ZERO
)
8689 tempreg
= treg
+ lp
;
8709 gas_assert (!mips_opts
.micromips
);
8712 /* Itbl support may require additional care here. */
8719 /* Itbl support may require additional care here. */
8727 offbits
= (mips_opts
.micromips
? 12 : 16);
8728 /* Itbl support may require additional care here. */
8733 gas_assert (!mips_opts
.micromips
);
8736 /* Itbl support may require additional care here. */
8744 offbits
= (mips_opts
.micromips
? 12 : 16);
8751 offbits
= (mips_opts
.micromips
? 12 : 16);
8758 offbits
= (mips_opts
.micromips
? 12 : 16);
8765 offbits
= (mips_opts
.micromips
? 12 : 16);
8771 fmt
= mips_opts
.micromips
? "k,~(b)" : "k,o(b)";
8772 offbits
= (mips_opts
.micromips
? 12 : 16);
8785 fmt
= !mips_opts
.micromips
? "k,o(b)" : "k,~(b)";
8786 offbits
= (mips_opts
.micromips
? 12 : 16);
8800 /* Itbl support may require additional care here. */
8807 offbits
= (mips_opts
.micromips
? 12 : 16);
8808 /* Itbl support may require additional care here. */
8815 /* Itbl support may require additional care here. */
8820 gas_assert (!mips_opts
.micromips
);
8823 /* Itbl support may require additional care here. */
8831 offbits
= (mips_opts
.micromips
? 12 : 16);
8838 offbits
= (mips_opts
.micromips
? 12 : 16);
8843 gas_assert (mips_opts
.micromips
);
8851 gas_assert (mips_opts
.micromips
);
8859 gas_assert (mips_opts
.micromips
);
8867 gas_assert (mips_opts
.micromips
);
8876 if (offset_expr
.X_op
!= O_constant
8877 && offset_expr
.X_op
!= O_symbol
)
8879 as_bad (_("Expression too complex"));
8880 offset_expr
.X_op
= O_constant
;
8883 if (HAVE_32BIT_ADDRESSES
8884 && !IS_SEXT_32BIT_NUM (offset_expr
.X_add_number
))
8888 sprintf_vma (value
, offset_expr
.X_add_number
);
8889 as_bad (_("Number (0x%s) larger than 32 bits"), value
);
8892 /* A constant expression in PIC code can be handled just as it
8893 is in non PIC code. */
8894 if (offset_expr
.X_op
== O_constant
)
8898 expr1
.X_add_number
= offset_expr
.X_add_number
;
8899 normalize_address_expr (&expr1
);
8900 if ((offbits
== 0 || offbits
== 16)
8901 && !IS_SEXT_16BIT_NUM (expr1
.X_add_number
))
8903 expr1
.X_add_number
= ((expr1
.X_add_number
+ 0x8000)
8904 & ~(bfd_vma
) 0xffff);
8907 else if (offbits
== 12 && !IS_SEXT_12BIT_NUM (expr1
.X_add_number
))
8909 expr1
.X_add_number
= ((expr1
.X_add_number
+ 0x800)
8910 & ~(bfd_vma
) 0xfff);
8913 else if (offbits
== 9 && !IS_SEXT_9BIT_NUM (expr1
.X_add_number
))
8915 expr1
.X_add_number
= ((expr1
.X_add_number
+ 0x100)
8916 & ~(bfd_vma
) 0x1ff);
8921 load_register (tempreg
, &expr1
, HAVE_64BIT_ADDRESSES
);
8923 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
8924 tempreg
, tempreg
, breg
);
8929 if (offset_expr
.X_add_number
== 0)
8932 macro_build (&offset_expr
, ADDRESS_ADDI_INSN
,
8933 "t,r,j", tempreg
, breg
, BFD_RELOC_LO16
);
8934 macro_build (NULL
, s
, fmt
, treg
, tempreg
);
8936 else if (offbits
== 16)
8937 macro_build (&offset_expr
, s
, fmt
, treg
, BFD_RELOC_LO16
, breg
);
8939 macro_build (NULL
, s
, fmt
,
8940 treg
, (unsigned long) offset_expr
.X_add_number
, breg
);
8942 else if (offbits
!= 16)
8944 /* The offset field is too narrow to be used for a low-part
8945 relocation, so load the whole address into the auxillary
8946 register. In the case of "A(b)" addresses, we first load
8947 absolute address "A" into the register and then add base
8948 register "b". In the case of "o(b)" addresses, we simply
8949 need to add 16-bit offset "o" to base register "b", and
8950 offset_reloc already contains the relocations associated
8954 load_address (tempreg
, &offset_expr
, &used_at
);
8956 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
8957 tempreg
, tempreg
, breg
);
8960 macro_build (&offset_expr
, ADDRESS_ADDI_INSN
, "t,r,j",
8962 offset_reloc
[0], offset_reloc
[1], offset_reloc
[2]);
8963 expr1
.X_add_number
= 0;
8965 macro_build (NULL
, s
, fmt
, treg
, tempreg
);
8967 macro_build (NULL
, s
, fmt
,
8968 treg
, (unsigned long) expr1
.X_add_number
, tempreg
);
8970 else if (mips_pic
== NO_PIC
)
8972 /* If this is a reference to a GP relative symbol, and there
8973 is no base register, we want
8974 <op> $treg,<sym>($gp) (BFD_RELOC_GPREL16)
8975 Otherwise, if there is no base register, we want
8976 lui $tempreg,<sym> (BFD_RELOC_HI16_S)
8977 <op> $treg,<sym>($tempreg) (BFD_RELOC_LO16)
8978 If we have a constant, we need two instructions anyhow,
8979 so we always use the latter form.
8981 If we have a base register, and this is a reference to a
8982 GP relative symbol, we want
8983 addu $tempreg,$breg,$gp
8984 <op> $treg,<sym>($tempreg) (BFD_RELOC_GPREL16)
8986 lui $tempreg,<sym> (BFD_RELOC_HI16_S)
8987 addu $tempreg,$tempreg,$breg
8988 <op> $treg,<sym>($tempreg) (BFD_RELOC_LO16)
8989 With a constant we always use the latter case.
8991 With 64bit address space and no base register and $at usable,
8993 lui $tempreg,<sym> (BFD_RELOC_MIPS_HIGHEST)
8994 lui $at,<sym> (BFD_RELOC_HI16_S)
8995 daddiu $tempreg,<sym> (BFD_RELOC_MIPS_HIGHER)
8998 <op> $treg,<sym>($tempreg) (BFD_RELOC_LO16)
8999 If we have a base register, we want
9000 lui $tempreg,<sym> (BFD_RELOC_MIPS_HIGHEST)
9001 lui $at,<sym> (BFD_RELOC_HI16_S)
9002 daddiu $tempreg,<sym> (BFD_RELOC_MIPS_HIGHER)
9006 <op> $treg,<sym>($tempreg) (BFD_RELOC_LO16)
9008 Without $at we can't generate the optimal path for superscalar
9009 processors here since this would require two temporary registers.
9010 lui $tempreg,<sym> (BFD_RELOC_MIPS_HIGHEST)
9011 daddiu $tempreg,<sym> (BFD_RELOC_MIPS_HIGHER)
9013 daddiu $tempreg,<sym> (BFD_RELOC_HI16_S)
9015 <op> $treg,<sym>($tempreg) (BFD_RELOC_LO16)
9016 If we have a base register, we want
9017 lui $tempreg,<sym> (BFD_RELOC_MIPS_HIGHEST)
9018 daddiu $tempreg,<sym> (BFD_RELOC_MIPS_HIGHER)
9020 daddiu $tempreg,<sym> (BFD_RELOC_HI16_S)
9022 daddu $tempreg,$tempreg,$breg
9023 <op> $treg,<sym>($tempreg) (BFD_RELOC_LO16)
9025 For GP relative symbols in 64bit address space we can use
9026 the same sequence as in 32bit address space. */
9027 if (HAVE_64BIT_SYMBOLS
)
9029 if ((valueT
) offset_expr
.X_add_number
<= MAX_GPREL_OFFSET
9030 && !nopic_need_relax (offset_expr
.X_add_symbol
, 1))
9032 relax_start (offset_expr
.X_add_symbol
);
9035 macro_build (&offset_expr
, s
, fmt
, treg
,
9036 BFD_RELOC_GPREL16
, mips_gp_register
);
9040 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
9041 tempreg
, breg
, mips_gp_register
);
9042 macro_build (&offset_expr
, s
, fmt
, treg
,
9043 BFD_RELOC_GPREL16
, tempreg
);
9048 if (used_at
== 0 && mips_opts
.at
)
9050 macro_build (&offset_expr
, "lui", LUI_FMT
, tempreg
,
9051 BFD_RELOC_MIPS_HIGHEST
);
9052 macro_build (&offset_expr
, "lui", LUI_FMT
, AT
,
9054 macro_build (&offset_expr
, "daddiu", "t,r,j", tempreg
,
9055 tempreg
, BFD_RELOC_MIPS_HIGHER
);
9057 macro_build (NULL
, "daddu", "d,v,t", AT
, AT
, breg
);
9058 macro_build (NULL
, "dsll32", SHFT_FMT
, tempreg
, tempreg
, 0);
9059 macro_build (NULL
, "daddu", "d,v,t", tempreg
, tempreg
, AT
);
9060 macro_build (&offset_expr
, s
, fmt
, treg
, BFD_RELOC_LO16
,
9066 macro_build (&offset_expr
, "lui", LUI_FMT
, tempreg
,
9067 BFD_RELOC_MIPS_HIGHEST
);
9068 macro_build (&offset_expr
, "daddiu", "t,r,j", tempreg
,
9069 tempreg
, BFD_RELOC_MIPS_HIGHER
);
9070 macro_build (NULL
, "dsll", SHFT_FMT
, tempreg
, tempreg
, 16);
9071 macro_build (&offset_expr
, "daddiu", "t,r,j", tempreg
,
9072 tempreg
, BFD_RELOC_HI16_S
);
9073 macro_build (NULL
, "dsll", SHFT_FMT
, tempreg
, tempreg
, 16);
9075 macro_build (NULL
, "daddu", "d,v,t",
9076 tempreg
, tempreg
, breg
);
9077 macro_build (&offset_expr
, s
, fmt
, treg
,
9078 BFD_RELOC_LO16
, tempreg
);
9081 if (mips_relax
.sequence
)
9088 if ((valueT
) offset_expr
.X_add_number
<= MAX_GPREL_OFFSET
9089 && !nopic_need_relax (offset_expr
.X_add_symbol
, 1))
9091 relax_start (offset_expr
.X_add_symbol
);
9092 macro_build (&offset_expr
, s
, fmt
, treg
, BFD_RELOC_GPREL16
,
9096 macro_build_lui (&offset_expr
, tempreg
);
9097 macro_build (&offset_expr
, s
, fmt
, treg
,
9098 BFD_RELOC_LO16
, tempreg
);
9099 if (mips_relax
.sequence
)
9104 if ((valueT
) offset_expr
.X_add_number
<= MAX_GPREL_OFFSET
9105 && !nopic_need_relax (offset_expr
.X_add_symbol
, 1))
9107 relax_start (offset_expr
.X_add_symbol
);
9108 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
9109 tempreg
, breg
, mips_gp_register
);
9110 macro_build (&offset_expr
, s
, fmt
, treg
,
9111 BFD_RELOC_GPREL16
, tempreg
);
9114 macro_build_lui (&offset_expr
, tempreg
);
9115 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
9116 tempreg
, tempreg
, breg
);
9117 macro_build (&offset_expr
, s
, fmt
, treg
,
9118 BFD_RELOC_LO16
, tempreg
);
9119 if (mips_relax
.sequence
)
9123 else if (!mips_big_got
)
9125 int lw_reloc_type
= (int) BFD_RELOC_MIPS_GOT16
;
9127 /* If this is a reference to an external symbol, we want
9128 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
9130 <op> $treg,0($tempreg)
9132 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
9134 addiu $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
9135 <op> $treg,0($tempreg)
9138 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT_PAGE)
9139 <op> $treg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_OFST)
9141 If there is a base register, we add it to $tempreg before
9142 the <op>. If there is a constant, we stick it in the
9143 <op> instruction. We don't handle constants larger than
9144 16 bits, because we have no way to load the upper 16 bits
9145 (actually, we could handle them for the subset of cases
9146 in which we are not using $at). */
9147 gas_assert (offset_expr
.X_op
== O_symbol
);
9150 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", tempreg
,
9151 BFD_RELOC_MIPS_GOT_PAGE
, mips_gp_register
);
9153 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
9154 tempreg
, tempreg
, breg
);
9155 macro_build (&offset_expr
, s
, fmt
, treg
,
9156 BFD_RELOC_MIPS_GOT_OFST
, tempreg
);
9159 expr1
.X_add_number
= offset_expr
.X_add_number
;
9160 offset_expr
.X_add_number
= 0;
9161 if (expr1
.X_add_number
< -0x8000
9162 || expr1
.X_add_number
>= 0x8000)
9163 as_bad (_("PIC code offset overflow (max 16 signed bits)"));
9164 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", tempreg
,
9165 lw_reloc_type
, mips_gp_register
);
9167 relax_start (offset_expr
.X_add_symbol
);
9169 macro_build (&offset_expr
, ADDRESS_ADDI_INSN
, "t,r,j", tempreg
,
9170 tempreg
, BFD_RELOC_LO16
);
9173 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
9174 tempreg
, tempreg
, breg
);
9175 macro_build (&expr1
, s
, fmt
, treg
, BFD_RELOC_LO16
, tempreg
);
9177 else if (mips_big_got
&& !HAVE_NEWABI
)
9181 /* If this is a reference to an external symbol, we want
9182 lui $tempreg,<sym> (BFD_RELOC_MIPS_GOT_HI16)
9183 addu $tempreg,$tempreg,$gp
9184 lw $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
9185 <op> $treg,0($tempreg)
9187 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
9189 addiu $tempreg,$tempreg,<sym> (BFD_RELOC_LO16)
9190 <op> $treg,0($tempreg)
9191 If there is a base register, we add it to $tempreg before
9192 the <op>. If there is a constant, we stick it in the
9193 <op> instruction. We don't handle constants larger than
9194 16 bits, because we have no way to load the upper 16 bits
9195 (actually, we could handle them for the subset of cases
9196 in which we are not using $at). */
9197 gas_assert (offset_expr
.X_op
== O_symbol
);
9198 expr1
.X_add_number
= offset_expr
.X_add_number
;
9199 offset_expr
.X_add_number
= 0;
9200 if (expr1
.X_add_number
< -0x8000
9201 || expr1
.X_add_number
>= 0x8000)
9202 as_bad (_("PIC code offset overflow (max 16 signed bits)"));
9203 gpdelay
= reg_needs_delay (mips_gp_register
);
9204 relax_start (offset_expr
.X_add_symbol
);
9205 macro_build (&offset_expr
, "lui", LUI_FMT
, tempreg
,
9206 BFD_RELOC_MIPS_GOT_HI16
);
9207 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t", tempreg
, tempreg
,
9209 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", tempreg
,
9210 BFD_RELOC_MIPS_GOT_LO16
, tempreg
);
9213 macro_build (NULL
, "nop", "");
9214 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", tempreg
,
9215 BFD_RELOC_MIPS_GOT16
, mips_gp_register
);
9217 macro_build (&offset_expr
, ADDRESS_ADDI_INSN
, "t,r,j", tempreg
,
9218 tempreg
, BFD_RELOC_LO16
);
9222 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
9223 tempreg
, tempreg
, breg
);
9224 macro_build (&expr1
, s
, fmt
, treg
, BFD_RELOC_LO16
, tempreg
);
9226 else if (mips_big_got
&& HAVE_NEWABI
)
9228 /* If this is a reference to an external symbol, we want
9229 lui $tempreg,<sym> (BFD_RELOC_MIPS_GOT_HI16)
9230 add $tempreg,$tempreg,$gp
9231 lw $tempreg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_LO16)
9232 <op> $treg,<ofst>($tempreg)
9233 Otherwise, for local symbols, we want:
9234 lw $tempreg,<sym>($gp) (BFD_RELOC_MIPS_GOT_PAGE)
9235 <op> $treg,<sym>($tempreg) (BFD_RELOC_MIPS_GOT_OFST) */
9236 gas_assert (offset_expr
.X_op
== O_symbol
);
9237 expr1
.X_add_number
= offset_expr
.X_add_number
;
9238 offset_expr
.X_add_number
= 0;
9239 if (expr1
.X_add_number
< -0x8000
9240 || expr1
.X_add_number
>= 0x8000)
9241 as_bad (_("PIC code offset overflow (max 16 signed bits)"));
9242 relax_start (offset_expr
.X_add_symbol
);
9243 macro_build (&offset_expr
, "lui", LUI_FMT
, tempreg
,
9244 BFD_RELOC_MIPS_GOT_HI16
);
9245 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t", tempreg
, tempreg
,
9247 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", tempreg
,
9248 BFD_RELOC_MIPS_GOT_LO16
, tempreg
);
9250 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
9251 tempreg
, tempreg
, breg
);
9252 macro_build (&expr1
, s
, fmt
, treg
, BFD_RELOC_LO16
, tempreg
);
9255 offset_expr
.X_add_number
= expr1
.X_add_number
;
9256 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", tempreg
,
9257 BFD_RELOC_MIPS_GOT_PAGE
, mips_gp_register
);
9259 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
9260 tempreg
, tempreg
, breg
);
9261 macro_build (&offset_expr
, s
, fmt
, treg
,
9262 BFD_RELOC_MIPS_GOT_OFST
, tempreg
);
9271 gas_assert (mips_opts
.micromips
);
9272 gas_assert (mips_opts
.insn32
);
9274 macro_build (NULL
, "jr", "s", RA
);
9275 expr1
.X_add_number
= EXTRACT_OPERAND (1, IMMP
, *ip
) << 2;
9276 macro_build (&expr1
, "addiu", "t,r,j", SP
, SP
, BFD_RELOC_LO16
);
9281 gas_assert (mips_opts
.micromips
);
9282 gas_assert (mips_opts
.insn32
);
9283 macro_build (NULL
, "jr", "s", sreg
);
9284 if (mips_opts
.noreorder
)
9285 macro_build (NULL
, "nop", "");
9290 load_register (treg
, &imm_expr
, 0);
9294 load_register (treg
, &imm_expr
, 1);
9298 if (imm_expr
.X_op
== O_constant
)
9301 load_register (AT
, &imm_expr
, 0);
9302 macro_build (NULL
, "mtc1", "t,G", AT
, treg
);
9307 gas_assert (offset_expr
.X_op
== O_symbol
9308 && strcmp (segment_name (S_GET_SEGMENT
9309 (offset_expr
.X_add_symbol
)),
9311 && offset_expr
.X_add_number
== 0);
9312 macro_build (&offset_expr
, "lwc1", "T,o(b)", treg
,
9313 BFD_RELOC_MIPS_LITERAL
, mips_gp_register
);
9318 /* Check if we have a constant in IMM_EXPR. If the GPRs are 64 bits
9319 wide, IMM_EXPR is the entire value. Otherwise IMM_EXPR is the high
9320 order 32 bits of the value and the low order 32 bits are either
9321 zero or in OFFSET_EXPR. */
9322 if (imm_expr
.X_op
== O_constant
|| imm_expr
.X_op
== O_big
)
9324 if (HAVE_64BIT_GPRS
)
9325 load_register (treg
, &imm_expr
, 1);
9330 if (target_big_endian
)
9342 load_register (hreg
, &imm_expr
, 0);
9345 if (offset_expr
.X_op
== O_absent
)
9346 move_register (lreg
, 0);
9349 gas_assert (offset_expr
.X_op
== O_constant
);
9350 load_register (lreg
, &offset_expr
, 0);
9357 /* We know that sym is in the .rdata section. First we get the
9358 upper 16 bits of the address. */
9359 if (mips_pic
== NO_PIC
)
9361 macro_build_lui (&offset_expr
, AT
);
9366 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", AT
,
9367 BFD_RELOC_MIPS_GOT16
, mips_gp_register
);
9371 /* Now we load the register(s). */
9372 if (HAVE_64BIT_GPRS
)
9375 macro_build (&offset_expr
, "ld", "t,o(b)", treg
, BFD_RELOC_LO16
, AT
);
9380 macro_build (&offset_expr
, "lw", "t,o(b)", treg
, BFD_RELOC_LO16
, AT
);
9383 /* FIXME: How in the world do we deal with the possible
9385 offset_expr
.X_add_number
+= 4;
9386 macro_build (&offset_expr
, "lw", "t,o(b)",
9387 treg
+ 1, BFD_RELOC_LO16
, AT
);
9393 /* Check if we have a constant in IMM_EXPR. If the FPRs are 64 bits
9394 wide, IMM_EXPR is the entire value and the GPRs are known to be 64
9395 bits wide as well. Otherwise IMM_EXPR is the high order 32 bits of
9396 the value and the low order 32 bits are either zero or in
9398 if (imm_expr
.X_op
== O_constant
|| imm_expr
.X_op
== O_big
)
9401 load_register (AT
, &imm_expr
, HAVE_64BIT_FPRS
);
9402 if (HAVE_64BIT_FPRS
)
9404 gas_assert (HAVE_64BIT_GPRS
);
9405 macro_build (NULL
, "dmtc1", "t,S", AT
, treg
);
9409 macro_build (NULL
, "mtc1", "t,G", AT
, treg
+ 1);
9410 if (offset_expr
.X_op
== O_absent
)
9411 macro_build (NULL
, "mtc1", "t,G", 0, treg
);
9414 gas_assert (offset_expr
.X_op
== O_constant
);
9415 load_register (AT
, &offset_expr
, 0);
9416 macro_build (NULL
, "mtc1", "t,G", AT
, treg
);
9422 gas_assert (offset_expr
.X_op
== O_symbol
9423 && offset_expr
.X_add_number
== 0);
9424 s
= segment_name (S_GET_SEGMENT (offset_expr
.X_add_symbol
));
9425 if (strcmp (s
, ".lit8") == 0)
9427 if (CPU_HAS_LDC1_SDC1 (mips_opts
.arch
) || mips_opts
.micromips
)
9429 macro_build (&offset_expr
, "ldc1", "T,o(b)", treg
,
9430 BFD_RELOC_MIPS_LITERAL
, mips_gp_register
);
9433 breg
= mips_gp_register
;
9434 r
= BFD_RELOC_MIPS_LITERAL
;
9439 gas_assert (strcmp (s
, RDATA_SECTION_NAME
) == 0);
9441 if (mips_pic
!= NO_PIC
)
9442 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", AT
,
9443 BFD_RELOC_MIPS_GOT16
, mips_gp_register
);
9446 /* FIXME: This won't work for a 64 bit address. */
9447 macro_build_lui (&offset_expr
, AT
);
9450 if (CPU_HAS_LDC1_SDC1 (mips_opts
.arch
) || mips_opts
.micromips
)
9452 macro_build (&offset_expr
, "ldc1", "T,o(b)",
9453 treg
, BFD_RELOC_LO16
, AT
);
9462 /* Even on a big endian machine $fn comes before $fn+1. We have
9463 to adjust when loading from memory. */
9466 gas_assert (!mips_opts
.micromips
);
9467 gas_assert (!CPU_HAS_LDC1_SDC1 (mips_opts
.arch
));
9468 macro_build (&offset_expr
, "lwc1", "T,o(b)",
9469 target_big_endian
? treg
+ 1 : treg
, r
, breg
);
9470 /* FIXME: A possible overflow which I don't know how to deal
9472 offset_expr
.X_add_number
+= 4;
9473 macro_build (&offset_expr
, "lwc1", "T,o(b)",
9474 target_big_endian
? treg
: treg
+ 1, r
, breg
);
9478 gas_assert (!mips_opts
.micromips
);
9479 gas_assert (!CPU_HAS_LDC1_SDC1 (mips_opts
.arch
));
9480 /* Even on a big endian machine $fn comes before $fn+1. We have
9481 to adjust when storing to memory. */
9482 macro_build (&offset_expr
, "swc1", "T,o(b)",
9483 target_big_endian
? treg
+ 1 : treg
, BFD_RELOC_LO16
, breg
);
9484 offset_expr
.X_add_number
+= 4;
9485 macro_build (&offset_expr
, "swc1", "T,o(b)",
9486 target_big_endian
? treg
: treg
+ 1, BFD_RELOC_LO16
, breg
);
9490 gas_assert (!mips_opts
.micromips
);
9492 * The MIPS assembler seems to check for X_add_number not
9493 * being double aligned and generating:
9496 * addiu at,at,%lo(foo+1)
9499 * But, the resulting address is the same after relocation so why
9500 * generate the extra instruction?
9502 /* Itbl support may require additional care here. */
9505 if (CPU_HAS_LDC1_SDC1 (mips_opts
.arch
))
9514 gas_assert (!mips_opts
.micromips
);
9515 /* Itbl support may require additional care here. */
9518 if (CPU_HAS_LDC1_SDC1 (mips_opts
.arch
))
9538 if (HAVE_64BIT_GPRS
)
9548 if (HAVE_64BIT_GPRS
)
9556 if (offset_expr
.X_op
!= O_symbol
9557 && offset_expr
.X_op
!= O_constant
)
9559 as_bad (_("Expression too complex"));
9560 offset_expr
.X_op
= O_constant
;
9563 if (HAVE_32BIT_ADDRESSES
9564 && !IS_SEXT_32BIT_NUM (offset_expr
.X_add_number
))
9568 sprintf_vma (value
, offset_expr
.X_add_number
);
9569 as_bad (_("Number (0x%s) larger than 32 bits"), value
);
9572 /* Even on a big endian machine $fn comes before $fn+1. We have
9573 to adjust when loading from memory. We set coproc if we must
9574 load $fn+1 first. */
9575 /* Itbl support may require additional care here. */
9576 if (!target_big_endian
)
9579 if (mips_pic
== NO_PIC
|| offset_expr
.X_op
== O_constant
)
9581 /* If this is a reference to a GP relative symbol, we want
9582 <op> $treg,<sym>($gp) (BFD_RELOC_GPREL16)
9583 <op> $treg+1,<sym>+4($gp) (BFD_RELOC_GPREL16)
9584 If we have a base register, we use this
9586 <op> $treg,<sym>($at) (BFD_RELOC_GPREL16)
9587 <op> $treg+1,<sym>+4($at) (BFD_RELOC_GPREL16)
9588 If this is not a GP relative symbol, we want
9589 lui $at,<sym> (BFD_RELOC_HI16_S)
9590 <op> $treg,<sym>($at) (BFD_RELOC_LO16)
9591 <op> $treg+1,<sym>+4($at) (BFD_RELOC_LO16)
9592 If there is a base register, we add it to $at after the
9593 lui instruction. If there is a constant, we always use
9595 if (offset_expr
.X_op
== O_symbol
9596 && (valueT
) offset_expr
.X_add_number
<= MAX_GPREL_OFFSET
9597 && !nopic_need_relax (offset_expr
.X_add_symbol
, 1))
9599 relax_start (offset_expr
.X_add_symbol
);
9602 tempreg
= mips_gp_register
;
9606 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
9607 AT
, breg
, mips_gp_register
);
9612 /* Itbl support may require additional care here. */
9613 macro_build (&offset_expr
, s
, fmt
, coproc
? treg
+ 1 : treg
,
9614 BFD_RELOC_GPREL16
, tempreg
);
9615 offset_expr
.X_add_number
+= 4;
9617 /* Set mips_optimize to 2 to avoid inserting an
9619 hold_mips_optimize
= mips_optimize
;
9621 /* Itbl support may require additional care here. */
9622 macro_build (&offset_expr
, s
, fmt
, coproc
? treg
: treg
+ 1,
9623 BFD_RELOC_GPREL16
, tempreg
);
9624 mips_optimize
= hold_mips_optimize
;
9628 offset_expr
.X_add_number
-= 4;
9631 macro_build_lui (&offset_expr
, AT
);
9633 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t", AT
, breg
, AT
);
9634 /* Itbl support may require additional care here. */
9635 macro_build (&offset_expr
, s
, fmt
, coproc
? treg
+ 1 : treg
,
9636 BFD_RELOC_LO16
, AT
);
9637 /* FIXME: How do we handle overflow here? */
9638 offset_expr
.X_add_number
+= 4;
9639 /* Itbl support may require additional care here. */
9640 macro_build (&offset_expr
, s
, fmt
, coproc
? treg
: treg
+ 1,
9641 BFD_RELOC_LO16
, AT
);
9642 if (mips_relax
.sequence
)
9645 else if (!mips_big_got
)
9647 /* If this is a reference to an external symbol, we want
9648 lw $at,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
9653 lw $at,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
9655 <op> $treg,<sym>($at) (BFD_RELOC_LO16)
9656 <op> $treg+1,<sym>+4($at) (BFD_RELOC_LO16)
9657 If there is a base register we add it to $at before the
9658 lwc1 instructions. If there is a constant we include it
9659 in the lwc1 instructions. */
9661 expr1
.X_add_number
= offset_expr
.X_add_number
;
9662 if (expr1
.X_add_number
< -0x8000
9663 || expr1
.X_add_number
>= 0x8000 - 4)
9664 as_bad (_("PIC code offset overflow (max 16 signed bits)"));
9665 load_got_offset (AT
, &offset_expr
);
9668 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t", AT
, breg
, AT
);
9670 /* Set mips_optimize to 2 to avoid inserting an undesired
9672 hold_mips_optimize
= mips_optimize
;
9675 /* Itbl support may require additional care here. */
9676 relax_start (offset_expr
.X_add_symbol
);
9677 macro_build (&expr1
, s
, fmt
, coproc
? treg
+ 1 : treg
,
9678 BFD_RELOC_LO16
, AT
);
9679 expr1
.X_add_number
+= 4;
9680 macro_build (&expr1
, s
, fmt
, coproc
? treg
: treg
+ 1,
9681 BFD_RELOC_LO16
, AT
);
9683 macro_build (&offset_expr
, s
, fmt
, coproc
? treg
+ 1 : treg
,
9684 BFD_RELOC_LO16
, AT
);
9685 offset_expr
.X_add_number
+= 4;
9686 macro_build (&offset_expr
, s
, fmt
, coproc
? treg
: treg
+ 1,
9687 BFD_RELOC_LO16
, AT
);
9690 mips_optimize
= hold_mips_optimize
;
9692 else if (mips_big_got
)
9696 /* If this is a reference to an external symbol, we want
9697 lui $at,<sym> (BFD_RELOC_MIPS_GOT_HI16)
9699 lw $at,<sym>($at) (BFD_RELOC_MIPS_GOT_LO16)
9704 lw $at,<sym>($gp) (BFD_RELOC_MIPS_GOT16)
9706 <op> $treg,<sym>($at) (BFD_RELOC_LO16)
9707 <op> $treg+1,<sym>+4($at) (BFD_RELOC_LO16)
9708 If there is a base register we add it to $at before the
9709 lwc1 instructions. If there is a constant we include it
9710 in the lwc1 instructions. */
9712 expr1
.X_add_number
= offset_expr
.X_add_number
;
9713 offset_expr
.X_add_number
= 0;
9714 if (expr1
.X_add_number
< -0x8000
9715 || expr1
.X_add_number
>= 0x8000 - 4)
9716 as_bad (_("PIC code offset overflow (max 16 signed bits)"));
9717 gpdelay
= reg_needs_delay (mips_gp_register
);
9718 relax_start (offset_expr
.X_add_symbol
);
9719 macro_build (&offset_expr
, "lui", LUI_FMT
,
9720 AT
, BFD_RELOC_MIPS_GOT_HI16
);
9721 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
9722 AT
, AT
, mips_gp_register
);
9723 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)",
9724 AT
, BFD_RELOC_MIPS_GOT_LO16
, AT
);
9727 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t", AT
, breg
, AT
);
9728 /* Itbl support may require additional care here. */
9729 macro_build (&expr1
, s
, fmt
, coproc
? treg
+ 1 : treg
,
9730 BFD_RELOC_LO16
, AT
);
9731 expr1
.X_add_number
+= 4;
9733 /* Set mips_optimize to 2 to avoid inserting an undesired
9735 hold_mips_optimize
= mips_optimize
;
9737 /* Itbl support may require additional care here. */
9738 macro_build (&expr1
, s
, fmt
, coproc
? treg
: treg
+ 1,
9739 BFD_RELOC_LO16
, AT
);
9740 mips_optimize
= hold_mips_optimize
;
9741 expr1
.X_add_number
-= 4;
9744 offset_expr
.X_add_number
= expr1
.X_add_number
;
9746 macro_build (NULL
, "nop", "");
9747 macro_build (&offset_expr
, ADDRESS_LOAD_INSN
, "t,o(b)", AT
,
9748 BFD_RELOC_MIPS_GOT16
, mips_gp_register
);
9751 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t", AT
, breg
, AT
);
9752 /* Itbl support may require additional care here. */
9753 macro_build (&offset_expr
, s
, fmt
, coproc
? treg
+ 1 : treg
,
9754 BFD_RELOC_LO16
, AT
);
9755 offset_expr
.X_add_number
+= 4;
9757 /* Set mips_optimize to 2 to avoid inserting an undesired
9759 hold_mips_optimize
= mips_optimize
;
9761 /* Itbl support may require additional care here. */
9762 macro_build (&offset_expr
, s
, fmt
, coproc
? treg
: treg
+ 1,
9763 BFD_RELOC_LO16
, AT
);
9764 mips_optimize
= hold_mips_optimize
;
9773 s
= HAVE_64BIT_GPRS
? "ld" : "lw";
9776 s
= HAVE_64BIT_GPRS
? "sd" : "sw";
9778 macro_build (&offset_expr
, s
, "t,o(b)", treg
,
9779 -1, offset_reloc
[0], offset_reloc
[1], offset_reloc
[2],
9781 if (!HAVE_64BIT_GPRS
)
9783 offset_expr
.X_add_number
+= 4;
9784 macro_build (&offset_expr
, s
, "t,o(b)", treg
+ 1,
9785 -1, offset_reloc
[0], offset_reloc
[1], offset_reloc
[2],
9806 /* New code added to support COPZ instructions.
9807 This code builds table entries out of the macros in mip_opcodes.
9808 R4000 uses interlocks to handle coproc delays.
9809 Other chips (like the R3000) require nops to be inserted for delays.
9811 FIXME: Currently, we require that the user handle delays.
9812 In order to fill delay slots for non-interlocked chips,
9813 we must have a way to specify delays based on the coprocessor.
9814 Eg. 4 cycles if load coproc reg from memory, 1 if in cache, etc.
9815 What are the side-effects of the cop instruction?
9816 What cache support might we have and what are its effects?
9817 Both coprocessor & memory require delays. how long???
9818 What registers are read/set/modified?
9820 If an itbl is provided to interpret cop instructions,
9821 this knowledge can be encoded in the itbl spec. */
9835 gas_assert (!mips_opts
.micromips
);
9836 /* For now we just do C (same as Cz). The parameter will be
9837 stored in insn_opcode by mips_ip. */
9838 macro_build (NULL
, s
, "C", ip
->insn_opcode
);
9842 move_register (dreg
, sreg
);
9846 gas_assert (mips_opts
.micromips
);
9847 gas_assert (mips_opts
.insn32
);
9848 dreg
= micromips_to_32_reg_h_map1
[EXTRACT_OPERAND (1, MH
, *ip
)];
9849 breg
= micromips_to_32_reg_h_map2
[EXTRACT_OPERAND (1, MH
, *ip
)];
9850 sreg
= micromips_to_32_reg_m_map
[EXTRACT_OPERAND (1, MM
, *ip
)];
9851 treg
= micromips_to_32_reg_n_map
[EXTRACT_OPERAND (1, MN
, *ip
)];
9852 move_register (dreg
, sreg
);
9853 move_register (breg
, treg
);
9859 if (mips_opts
.arch
== CPU_R5900
)
9861 macro_build (NULL
, dbl
? "dmultu" : "multu", "d,s,t", dreg
, sreg
, treg
);
9865 macro_build (NULL
, dbl
? "dmultu" : "multu", "s,t", sreg
, treg
);
9866 macro_build (NULL
, "mflo", MFHL_FMT
, dreg
);
9873 /* The MIPS assembler some times generates shifts and adds. I'm
9874 not trying to be that fancy. GCC should do this for us
9877 load_register (AT
, &imm_expr
, dbl
);
9878 macro_build (NULL
, dbl
? "dmult" : "mult", "s,t", sreg
, AT
);
9879 macro_build (NULL
, "mflo", MFHL_FMT
, dreg
);
9895 load_register (AT
, &imm_expr
, dbl
);
9896 macro_build (NULL
, dbl
? "dmult" : "mult", "s,t", sreg
, imm
? AT
: treg
);
9897 macro_build (NULL
, "mflo", MFHL_FMT
, dreg
);
9898 macro_build (NULL
, dbl
? "dsra32" : "sra", SHFT_FMT
, dreg
, dreg
, RA
);
9899 macro_build (NULL
, "mfhi", MFHL_FMT
, AT
);
9901 macro_build (NULL
, "tne", TRAP_FMT
, dreg
, AT
, 6);
9904 if (mips_opts
.micromips
)
9905 micromips_label_expr (&label_expr
);
9907 label_expr
.X_add_number
= 8;
9908 macro_build (&label_expr
, "beq", "s,t,p", dreg
, AT
);
9909 macro_build (NULL
, "nop", "");
9910 macro_build (NULL
, "break", BRK_FMT
, 6);
9911 if (mips_opts
.micromips
)
9912 micromips_add_label ();
9915 macro_build (NULL
, "mflo", MFHL_FMT
, dreg
);
9931 load_register (AT
, &imm_expr
, dbl
);
9932 macro_build (NULL
, dbl
? "dmultu" : "multu", "s,t",
9933 sreg
, imm
? AT
: treg
);
9934 macro_build (NULL
, "mfhi", MFHL_FMT
, AT
);
9935 macro_build (NULL
, "mflo", MFHL_FMT
, dreg
);
9937 macro_build (NULL
, "tne", TRAP_FMT
, AT
, ZERO
, 6);
9940 if (mips_opts
.micromips
)
9941 micromips_label_expr (&label_expr
);
9943 label_expr
.X_add_number
= 8;
9944 macro_build (&label_expr
, "beq", "s,t,p", AT
, ZERO
);
9945 macro_build (NULL
, "nop", "");
9946 macro_build (NULL
, "break", BRK_FMT
, 6);
9947 if (mips_opts
.micromips
)
9948 micromips_add_label ();
9954 if (ISA_HAS_DROR (mips_opts
.isa
) || CPU_HAS_DROR (mips_opts
.arch
))
9965 macro_build (NULL
, "dnegu", "d,w", tempreg
, treg
);
9966 macro_build (NULL
, "drorv", "d,t,s", dreg
, sreg
, tempreg
);
9970 macro_build (NULL
, "dsubu", "d,v,t", AT
, ZERO
, treg
);
9971 macro_build (NULL
, "dsrlv", "d,t,s", AT
, sreg
, AT
);
9972 macro_build (NULL
, "dsllv", "d,t,s", dreg
, sreg
, treg
);
9973 macro_build (NULL
, "or", "d,v,t", dreg
, dreg
, AT
);
9977 if (ISA_HAS_ROR (mips_opts
.isa
) || CPU_HAS_ROR (mips_opts
.arch
))
9988 macro_build (NULL
, "negu", "d,w", tempreg
, treg
);
9989 macro_build (NULL
, "rorv", "d,t,s", dreg
, sreg
, tempreg
);
9993 macro_build (NULL
, "subu", "d,v,t", AT
, ZERO
, treg
);
9994 macro_build (NULL
, "srlv", "d,t,s", AT
, sreg
, AT
);
9995 macro_build (NULL
, "sllv", "d,t,s", dreg
, sreg
, treg
);
9996 macro_build (NULL
, "or", "d,v,t", dreg
, dreg
, AT
);
10005 if (imm_expr
.X_op
!= O_constant
)
10006 as_bad (_("Improper rotate count"));
10007 rot
= imm_expr
.X_add_number
& 0x3f;
10008 if (ISA_HAS_DROR (mips_opts
.isa
) || CPU_HAS_DROR (mips_opts
.arch
))
10010 rot
= (64 - rot
) & 0x3f;
10012 macro_build (NULL
, "dror32", SHFT_FMT
, dreg
, sreg
, rot
- 32);
10014 macro_build (NULL
, "dror", SHFT_FMT
, dreg
, sreg
, rot
);
10019 macro_build (NULL
, "dsrl", SHFT_FMT
, dreg
, sreg
, 0);
10022 l
= (rot
< 0x20) ? "dsll" : "dsll32";
10023 rr
= ((0x40 - rot
) < 0x20) ? "dsrl" : "dsrl32";
10026 macro_build (NULL
, l
, SHFT_FMT
, AT
, sreg
, rot
);
10027 macro_build (NULL
, rr
, SHFT_FMT
, dreg
, sreg
, (0x20 - rot
) & 0x1f);
10028 macro_build (NULL
, "or", "d,v,t", dreg
, dreg
, AT
);
10036 if (imm_expr
.X_op
!= O_constant
)
10037 as_bad (_("Improper rotate count"));
10038 rot
= imm_expr
.X_add_number
& 0x1f;
10039 if (ISA_HAS_ROR (mips_opts
.isa
) || CPU_HAS_ROR (mips_opts
.arch
))
10041 macro_build (NULL
, "ror", SHFT_FMT
, dreg
, sreg
, (32 - rot
) & 0x1f);
10046 macro_build (NULL
, "srl", SHFT_FMT
, dreg
, sreg
, 0);
10050 macro_build (NULL
, "sll", SHFT_FMT
, AT
, sreg
, rot
);
10051 macro_build (NULL
, "srl", SHFT_FMT
, dreg
, sreg
, (0x20 - rot
) & 0x1f);
10052 macro_build (NULL
, "or", "d,v,t", dreg
, dreg
, AT
);
10057 if (ISA_HAS_DROR (mips_opts
.isa
) || CPU_HAS_DROR (mips_opts
.arch
))
10059 macro_build (NULL
, "drorv", "d,t,s", dreg
, sreg
, treg
);
10063 macro_build (NULL
, "dsubu", "d,v,t", AT
, ZERO
, treg
);
10064 macro_build (NULL
, "dsllv", "d,t,s", AT
, sreg
, AT
);
10065 macro_build (NULL
, "dsrlv", "d,t,s", dreg
, sreg
, treg
);
10066 macro_build (NULL
, "or", "d,v,t", dreg
, dreg
, AT
);
10070 if (ISA_HAS_ROR (mips_opts
.isa
) || CPU_HAS_ROR (mips_opts
.arch
))
10072 macro_build (NULL
, "rorv", "d,t,s", dreg
, sreg
, treg
);
10076 macro_build (NULL
, "subu", "d,v,t", AT
, ZERO
, treg
);
10077 macro_build (NULL
, "sllv", "d,t,s", AT
, sreg
, AT
);
10078 macro_build (NULL
, "srlv", "d,t,s", dreg
, sreg
, treg
);
10079 macro_build (NULL
, "or", "d,v,t", dreg
, dreg
, AT
);
10088 if (imm_expr
.X_op
!= O_constant
)
10089 as_bad (_("Improper rotate count"));
10090 rot
= imm_expr
.X_add_number
& 0x3f;
10091 if (ISA_HAS_DROR (mips_opts
.isa
) || CPU_HAS_DROR (mips_opts
.arch
))
10094 macro_build (NULL
, "dror32", SHFT_FMT
, dreg
, sreg
, rot
- 32);
10096 macro_build (NULL
, "dror", SHFT_FMT
, dreg
, sreg
, rot
);
10101 macro_build (NULL
, "dsrl", SHFT_FMT
, dreg
, sreg
, 0);
10104 rr
= (rot
< 0x20) ? "dsrl" : "dsrl32";
10105 l
= ((0x40 - rot
) < 0x20) ? "dsll" : "dsll32";
10108 macro_build (NULL
, rr
, SHFT_FMT
, AT
, sreg
, rot
);
10109 macro_build (NULL
, l
, SHFT_FMT
, dreg
, sreg
, (0x20 - rot
) & 0x1f);
10110 macro_build (NULL
, "or", "d,v,t", dreg
, dreg
, AT
);
10118 if (imm_expr
.X_op
!= O_constant
)
10119 as_bad (_("Improper rotate count"));
10120 rot
= imm_expr
.X_add_number
& 0x1f;
10121 if (ISA_HAS_ROR (mips_opts
.isa
) || CPU_HAS_ROR (mips_opts
.arch
))
10123 macro_build (NULL
, "ror", SHFT_FMT
, dreg
, sreg
, rot
);
10128 macro_build (NULL
, "srl", SHFT_FMT
, dreg
, sreg
, 0);
10132 macro_build (NULL
, "srl", SHFT_FMT
, AT
, sreg
, rot
);
10133 macro_build (NULL
, "sll", SHFT_FMT
, dreg
, sreg
, (0x20 - rot
) & 0x1f);
10134 macro_build (NULL
, "or", "d,v,t", dreg
, dreg
, AT
);
10140 macro_build (&expr1
, "sltiu", "t,r,j", dreg
, treg
, BFD_RELOC_LO16
);
10141 else if (treg
== 0)
10142 macro_build (&expr1
, "sltiu", "t,r,j", dreg
, sreg
, BFD_RELOC_LO16
);
10145 macro_build (NULL
, "xor", "d,v,t", dreg
, sreg
, treg
);
10146 macro_build (&expr1
, "sltiu", "t,r,j", dreg
, dreg
, BFD_RELOC_LO16
);
10151 if (imm_expr
.X_op
== O_constant
&& imm_expr
.X_add_number
== 0)
10153 macro_build (&expr1
, "sltiu", "t,r,j", dreg
, sreg
, BFD_RELOC_LO16
);
10158 as_warn (_("Instruction %s: result is always false"),
10159 ip
->insn_mo
->name
);
10160 move_register (dreg
, 0);
10163 if (CPU_HAS_SEQ (mips_opts
.arch
)
10164 && -512 <= imm_expr
.X_add_number
10165 && imm_expr
.X_add_number
< 512)
10167 macro_build (NULL
, "seqi", "t,r,+Q", dreg
, sreg
,
10168 (int) imm_expr
.X_add_number
);
10171 if (imm_expr
.X_op
== O_constant
10172 && imm_expr
.X_add_number
>= 0
10173 && imm_expr
.X_add_number
< 0x10000)
10175 macro_build (&imm_expr
, "xori", "t,r,i", dreg
, sreg
, BFD_RELOC_LO16
);
10177 else if (imm_expr
.X_op
== O_constant
10178 && imm_expr
.X_add_number
> -0x8000
10179 && imm_expr
.X_add_number
< 0)
10181 imm_expr
.X_add_number
= -imm_expr
.X_add_number
;
10182 macro_build (&imm_expr
, HAVE_32BIT_GPRS
? "addiu" : "daddiu",
10183 "t,r,j", dreg
, sreg
, BFD_RELOC_LO16
);
10185 else if (CPU_HAS_SEQ (mips_opts
.arch
))
10188 load_register (AT
, &imm_expr
, HAVE_64BIT_GPRS
);
10189 macro_build (NULL
, "seq", "d,v,t", dreg
, sreg
, AT
);
10194 load_register (AT
, &imm_expr
, HAVE_64BIT_GPRS
);
10195 macro_build (NULL
, "xor", "d,v,t", dreg
, sreg
, AT
);
10198 macro_build (&expr1
, "sltiu", "t,r,j", dreg
, dreg
, BFD_RELOC_LO16
);
10201 case M_SGE
: /* sreg >= treg <==> not (sreg < treg) */
10207 macro_build (NULL
, s
, "d,v,t", dreg
, sreg
, treg
);
10208 macro_build (&expr1
, "xori", "t,r,i", dreg
, dreg
, BFD_RELOC_LO16
);
10211 case M_SGE_I
: /* sreg >= I <==> not (sreg < I) */
10213 if (imm_expr
.X_op
== O_constant
10214 && imm_expr
.X_add_number
>= -0x8000
10215 && imm_expr
.X_add_number
< 0x8000)
10217 macro_build (&imm_expr
, mask
== M_SGE_I
? "slti" : "sltiu", "t,r,j",
10218 dreg
, sreg
, BFD_RELOC_LO16
);
10222 load_register (AT
, &imm_expr
, HAVE_64BIT_GPRS
);
10223 macro_build (NULL
, mask
== M_SGE_I
? "slt" : "sltu", "d,v,t",
10227 macro_build (&expr1
, "xori", "t,r,i", dreg
, dreg
, BFD_RELOC_LO16
);
10230 case M_SGT
: /* sreg > treg <==> treg < sreg */
10236 macro_build (NULL
, s
, "d,v,t", dreg
, treg
, sreg
);
10239 case M_SGT_I
: /* sreg > I <==> I < sreg */
10246 load_register (AT
, &imm_expr
, HAVE_64BIT_GPRS
);
10247 macro_build (NULL
, s
, "d,v,t", dreg
, AT
, sreg
);
10250 case M_SLE
: /* sreg <= treg <==> treg >= sreg <==> not (treg < sreg) */
10256 macro_build (NULL
, s
, "d,v,t", dreg
, treg
, sreg
);
10257 macro_build (&expr1
, "xori", "t,r,i", dreg
, dreg
, BFD_RELOC_LO16
);
10260 case M_SLE_I
: /* sreg <= I <==> I >= sreg <==> not (I < sreg) */
10267 load_register (AT
, &imm_expr
, HAVE_64BIT_GPRS
);
10268 macro_build (NULL
, s
, "d,v,t", dreg
, AT
, sreg
);
10269 macro_build (&expr1
, "xori", "t,r,i", dreg
, dreg
, BFD_RELOC_LO16
);
10273 if (imm_expr
.X_op
== O_constant
10274 && imm_expr
.X_add_number
>= -0x8000
10275 && imm_expr
.X_add_number
< 0x8000)
10277 macro_build (&imm_expr
, "slti", "t,r,j", dreg
, sreg
, BFD_RELOC_LO16
);
10281 load_register (AT
, &imm_expr
, HAVE_64BIT_GPRS
);
10282 macro_build (NULL
, "slt", "d,v,t", dreg
, sreg
, AT
);
10286 if (imm_expr
.X_op
== O_constant
10287 && imm_expr
.X_add_number
>= -0x8000
10288 && imm_expr
.X_add_number
< 0x8000)
10290 macro_build (&imm_expr
, "sltiu", "t,r,j", dreg
, sreg
,
10295 load_register (AT
, &imm_expr
, HAVE_64BIT_GPRS
);
10296 macro_build (NULL
, "sltu", "d,v,t", dreg
, sreg
, AT
);
10301 macro_build (NULL
, "sltu", "d,v,t", dreg
, 0, treg
);
10302 else if (treg
== 0)
10303 macro_build (NULL
, "sltu", "d,v,t", dreg
, 0, sreg
);
10306 macro_build (NULL
, "xor", "d,v,t", dreg
, sreg
, treg
);
10307 macro_build (NULL
, "sltu", "d,v,t", dreg
, 0, dreg
);
10312 if (imm_expr
.X_op
== O_constant
&& imm_expr
.X_add_number
== 0)
10314 macro_build (NULL
, "sltu", "d,v,t", dreg
, 0, sreg
);
10319 as_warn (_("Instruction %s: result is always true"),
10320 ip
->insn_mo
->name
);
10321 macro_build (&expr1
, HAVE_32BIT_GPRS
? "addiu" : "daddiu", "t,r,j",
10322 dreg
, 0, BFD_RELOC_LO16
);
10325 if (CPU_HAS_SEQ (mips_opts
.arch
)
10326 && -512 <= imm_expr
.X_add_number
10327 && imm_expr
.X_add_number
< 512)
10329 macro_build (NULL
, "snei", "t,r,+Q", dreg
, sreg
,
10330 (int) imm_expr
.X_add_number
);
10333 if (imm_expr
.X_op
== O_constant
10334 && imm_expr
.X_add_number
>= 0
10335 && imm_expr
.X_add_number
< 0x10000)
10337 macro_build (&imm_expr
, "xori", "t,r,i", dreg
, sreg
, BFD_RELOC_LO16
);
10339 else if (imm_expr
.X_op
== O_constant
10340 && imm_expr
.X_add_number
> -0x8000
10341 && imm_expr
.X_add_number
< 0)
10343 imm_expr
.X_add_number
= -imm_expr
.X_add_number
;
10344 macro_build (&imm_expr
, HAVE_32BIT_GPRS
? "addiu" : "daddiu",
10345 "t,r,j", dreg
, sreg
, BFD_RELOC_LO16
);
10347 else if (CPU_HAS_SEQ (mips_opts
.arch
))
10350 load_register (AT
, &imm_expr
, HAVE_64BIT_GPRS
);
10351 macro_build (NULL
, "sne", "d,v,t", dreg
, sreg
, AT
);
10356 load_register (AT
, &imm_expr
, HAVE_64BIT_GPRS
);
10357 macro_build (NULL
, "xor", "d,v,t", dreg
, sreg
, AT
);
10360 macro_build (NULL
, "sltu", "d,v,t", dreg
, 0, dreg
);
10375 if (!mips_opts
.micromips
)
10377 if (imm_expr
.X_op
== O_constant
10378 && imm_expr
.X_add_number
> -0x200
10379 && imm_expr
.X_add_number
<= 0x200)
10381 macro_build (NULL
, s
, "t,r,.", dreg
, sreg
, -imm_expr
.X_add_number
);
10390 if (imm_expr
.X_op
== O_constant
10391 && imm_expr
.X_add_number
> -0x8000
10392 && imm_expr
.X_add_number
<= 0x8000)
10394 imm_expr
.X_add_number
= -imm_expr
.X_add_number
;
10395 macro_build (&imm_expr
, s
, "t,r,j", dreg
, sreg
, BFD_RELOC_LO16
);
10400 load_register (AT
, &imm_expr
, dbl
);
10401 macro_build (NULL
, s2
, "d,v,t", dreg
, sreg
, AT
);
10423 load_register (AT
, &imm_expr
, HAVE_64BIT_GPRS
);
10424 macro_build (NULL
, s
, "s,t", sreg
, AT
);
10429 gas_assert (!mips_opts
.micromips
);
10430 gas_assert (mips_opts
.isa
== ISA_MIPS1
);
10432 sreg
= (ip
->insn_opcode
>> 11) & 0x1f; /* floating reg */
10433 dreg
= (ip
->insn_opcode
>> 06) & 0x1f; /* floating reg */
10436 * Is the double cfc1 instruction a bug in the mips assembler;
10437 * or is there a reason for it?
10439 start_noreorder ();
10440 macro_build (NULL
, "cfc1", "t,G", treg
, RA
);
10441 macro_build (NULL
, "cfc1", "t,G", treg
, RA
);
10442 macro_build (NULL
, "nop", "");
10443 expr1
.X_add_number
= 3;
10444 macro_build (&expr1
, "ori", "t,r,i", AT
, treg
, BFD_RELOC_LO16
);
10445 expr1
.X_add_number
= 2;
10446 macro_build (&expr1
, "xori", "t,r,i", AT
, AT
, BFD_RELOC_LO16
);
10447 macro_build (NULL
, "ctc1", "t,G", AT
, RA
);
10448 macro_build (NULL
, "nop", "");
10449 macro_build (NULL
, mask
== M_TRUNCWD
? "cvt.w.d" : "cvt.w.s", "D,S",
10451 macro_build (NULL
, "ctc1", "t,G", treg
, RA
);
10452 macro_build (NULL
, "nop", "");
10475 offbits
= (mips_opts
.micromips
? 12 : 16);
10483 offbits
= (mips_opts
.micromips
? 12 : 16);
10499 offbits
= (mips_opts
.micromips
? 12 : 16);
10508 offbits
= (mips_opts
.micromips
? 12 : 16);
10513 if (!ab
&& offset_expr
.X_add_number
>= 0x8000 - off
)
10514 as_bad (_("Operand overflow"));
10517 expr1
.X_add_number
= 0;
10522 load_address (tempreg
, ep
, &used_at
);
10524 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t",
10525 tempreg
, tempreg
, breg
);
10530 else if (offbits
== 12
10531 && (offset_expr
.X_op
!= O_constant
10532 || !IS_SEXT_12BIT_NUM (offset_expr
.X_add_number
)
10533 || !IS_SEXT_12BIT_NUM (offset_expr
.X_add_number
+ off
)))
10537 macro_build (ep
, ADDRESS_ADDI_INSN
, "t,r,j", tempreg
, breg
,
10538 -1, offset_reloc
[0], offset_reloc
[1], offset_reloc
[2]);
10543 else if (!ust
&& treg
== breg
)
10554 if (!target_big_endian
)
10555 ep
->X_add_number
+= off
;
10557 macro_build (ep
, s
, "t,o(b)", tempreg
, BFD_RELOC_LO16
, breg
);
10559 macro_build (NULL
, s
, "t,~(b)",
10560 tempreg
, (unsigned long) ep
->X_add_number
, breg
);
10562 if (!target_big_endian
)
10563 ep
->X_add_number
-= off
;
10565 ep
->X_add_number
+= off
;
10567 macro_build (ep
, s2
, "t,o(b)", tempreg
, BFD_RELOC_LO16
, breg
);
10569 macro_build (NULL
, s2
, "t,~(b)",
10570 tempreg
, (unsigned long) ep
->X_add_number
, breg
);
10572 /* If necessary, move the result in tempreg to the final destination. */
10573 if (!ust
&& treg
!= tempreg
)
10575 /* Protect second load's delay slot. */
10577 move_register (treg
, tempreg
);
10583 if (target_big_endian
== ust
)
10584 ep
->X_add_number
+= off
;
10585 tempreg
= ust
|| ab
? treg
: AT
;
10586 macro_build (ep
, s
, "t,o(b)", tempreg
, BFD_RELOC_LO16
, breg
);
10588 /* For halfword transfers we need a temporary register to shuffle
10589 bytes. Unfortunately for M_USH_A we have none available before
10590 the next store as AT holds the base address. We deal with this
10591 case by clobbering TREG and then restoring it as with ULH. */
10592 tempreg
= ust
== ab
? treg
: AT
;
10594 macro_build (NULL
, "srl", SHFT_FMT
, tempreg
, treg
, 8);
10596 if (target_big_endian
== ust
)
10597 ep
->X_add_number
-= off
;
10599 ep
->X_add_number
+= off
;
10600 macro_build (ep
, s2
, "t,o(b)", tempreg
, BFD_RELOC_LO16
, breg
);
10602 /* For M_USH_A re-retrieve the LSB. */
10605 if (target_big_endian
)
10606 ep
->X_add_number
+= off
;
10608 ep
->X_add_number
-= off
;
10609 macro_build (&expr1
, "lbu", "t,o(b)", AT
, BFD_RELOC_LO16
, AT
);
10611 /* For ULH and M_USH_A OR the LSB in. */
10614 tempreg
= !ab
? AT
: treg
;
10615 macro_build (NULL
, "sll", SHFT_FMT
, tempreg
, tempreg
, 8);
10616 macro_build (NULL
, "or", "d,v,t", treg
, treg
, AT
);
10621 /* FIXME: Check if this is one of the itbl macros, since they
10622 are added dynamically. */
10623 as_bad (_("Macro %s not implemented yet"), ip
->insn_mo
->name
);
10626 if (!mips_opts
.at
&& used_at
)
10627 as_bad (_("Macro used $at after \".set noat\""));
10630 /* Implement macros in mips16 mode. */
10633 mips16_macro (struct mips_cl_insn
*ip
)
10636 int xreg
, yreg
, zreg
, tmp
;
10639 const char *s
, *s2
, *s3
;
10641 mask
= ip
->insn_mo
->mask
;
10643 xreg
= MIPS16_EXTRACT_OPERAND (RX
, *ip
);
10644 yreg
= MIPS16_EXTRACT_OPERAND (RY
, *ip
);
10645 zreg
= MIPS16_EXTRACT_OPERAND (RZ
, *ip
);
10647 expr1
.X_op
= O_constant
;
10648 expr1
.X_op_symbol
= NULL
;
10649 expr1
.X_add_symbol
= NULL
;
10650 expr1
.X_add_number
= 1;
10669 start_noreorder ();
10670 macro_build (NULL
, dbl
? "ddiv" : "div", "0,x,y", xreg
, yreg
);
10671 expr1
.X_add_number
= 2;
10672 macro_build (&expr1
, "bnez", "x,p", yreg
);
10673 macro_build (NULL
, "break", "6", 7);
10675 /* FIXME: The normal code checks for of -1 / -0x80000000 here,
10676 since that causes an overflow. We should do that as well,
10677 but I don't see how to do the comparisons without a temporary
10680 macro_build (NULL
, s
, "x", zreg
);
10699 start_noreorder ();
10700 macro_build (NULL
, s
, "0,x,y", xreg
, yreg
);
10701 expr1
.X_add_number
= 2;
10702 macro_build (&expr1
, "bnez", "x,p", yreg
);
10703 macro_build (NULL
, "break", "6", 7);
10705 macro_build (NULL
, s2
, "x", zreg
);
10711 macro_build (NULL
, dbl
? "dmultu" : "multu", "x,y", xreg
, yreg
);
10712 macro_build (NULL
, "mflo", "x", zreg
);
10720 if (imm_expr
.X_op
!= O_constant
)
10721 as_bad (_("Unsupported large constant"));
10722 imm_expr
.X_add_number
= -imm_expr
.X_add_number
;
10723 macro_build (&imm_expr
, dbl
? "daddiu" : "addiu", "y,x,4", yreg
, xreg
);
10727 if (imm_expr
.X_op
!= O_constant
)
10728 as_bad (_("Unsupported large constant"));
10729 imm_expr
.X_add_number
= -imm_expr
.X_add_number
;
10730 macro_build (&imm_expr
, "addiu", "x,k", xreg
);
10734 if (imm_expr
.X_op
!= O_constant
)
10735 as_bad (_("Unsupported large constant"));
10736 imm_expr
.X_add_number
= -imm_expr
.X_add_number
;
10737 macro_build (&imm_expr
, "daddiu", "y,j", yreg
);
10759 goto do_reverse_branch
;
10763 goto do_reverse_branch
;
10775 goto do_reverse_branch
;
10786 macro_build (NULL
, s
, "x,y", xreg
, yreg
);
10787 macro_build (&offset_expr
, s2
, "p");
10814 goto do_addone_branch_i
;
10819 goto do_addone_branch_i
;
10834 goto do_addone_branch_i
;
10840 do_addone_branch_i
:
10841 if (imm_expr
.X_op
!= O_constant
)
10842 as_bad (_("Unsupported large constant"));
10843 ++imm_expr
.X_add_number
;
10846 macro_build (&imm_expr
, s
, s3
, xreg
);
10847 macro_build (&offset_expr
, s2
, "p");
10851 expr1
.X_add_number
= 0;
10852 macro_build (&expr1
, "slti", "x,8", yreg
);
10854 move_register (xreg
, yreg
);
10855 expr1
.X_add_number
= 2;
10856 macro_build (&expr1
, "bteqz", "p");
10857 macro_build (NULL
, "neg", "x,w", xreg
, xreg
);
10861 /* For consistency checking, verify that all bits are specified either
10862 by the match/mask part of the instruction definition, or by the
10865 validate_mips_insn (const struct mips_opcode
*opc
)
10867 const char *p
= opc
->args
;
10869 unsigned long used_bits
= opc
->mask
;
10871 if ((used_bits
& opc
->match
) != opc
->match
)
10873 as_bad (_("internal: bad mips opcode (mask error): %s %s"),
10874 opc
->name
, opc
->args
);
10877 #define USE_BITS(mask,shift) (used_bits |= ((mask) << (shift)))
10887 case '1': USE_BITS (OP_MASK_UDI1
, OP_SH_UDI1
); break;
10888 case '2': USE_BITS (OP_MASK_UDI2
, OP_SH_UDI2
); break;
10889 case '3': USE_BITS (OP_MASK_UDI3
, OP_SH_UDI3
); break;
10890 case '4': USE_BITS (OP_MASK_UDI4
, OP_SH_UDI4
); break;
10891 case 'A': USE_BITS (OP_MASK_SHAMT
, OP_SH_SHAMT
); break;
10892 case 'B': USE_BITS (OP_MASK_INSMSB
, OP_SH_INSMSB
); break;
10893 case 'C': USE_BITS (OP_MASK_EXTMSBD
, OP_SH_EXTMSBD
); break;
10894 case 'E': USE_BITS (OP_MASK_SHAMT
, OP_SH_SHAMT
); break;
10895 case 'F': USE_BITS (OP_MASK_INSMSB
, OP_SH_INSMSB
); break;
10896 case 'G': USE_BITS (OP_MASK_EXTMSBD
, OP_SH_EXTMSBD
); break;
10897 case 'H': USE_BITS (OP_MASK_EXTMSBD
, OP_SH_EXTMSBD
); break;
10899 case 'J': USE_BITS (OP_MASK_CODE10
, OP_SH_CODE10
); break;
10900 case 't': USE_BITS (OP_MASK_RT
, OP_SH_RT
); break;
10901 case 'x': USE_BITS (OP_MASK_BBITIND
, OP_SH_BBITIND
); break;
10902 case 'X': USE_BITS (OP_MASK_BBITIND
, OP_SH_BBITIND
); break;
10903 case 'p': USE_BITS (OP_MASK_CINSPOS
, OP_SH_CINSPOS
); break;
10904 case 'P': USE_BITS (OP_MASK_CINSPOS
, OP_SH_CINSPOS
); break;
10905 case 'Q': USE_BITS (OP_MASK_SEQI
, OP_SH_SEQI
); break;
10906 case 's': USE_BITS (OP_MASK_CINSLM1
, OP_SH_CINSLM1
); break;
10907 case 'S': USE_BITS (OP_MASK_CINSLM1
, OP_SH_CINSLM1
); break;
10908 case 'z': USE_BITS (OP_MASK_RZ
, OP_SH_RZ
); break;
10909 case 'Z': USE_BITS (OP_MASK_FZ
, OP_SH_FZ
); break;
10910 case 'a': USE_BITS (OP_MASK_OFFSET_A
, OP_SH_OFFSET_A
); break;
10911 case 'b': USE_BITS (OP_MASK_OFFSET_B
, OP_SH_OFFSET_B
); break;
10912 case 'c': USE_BITS (OP_MASK_OFFSET_C
, OP_SH_OFFSET_C
); break;
10913 case 'i': USE_BITS (OP_MASK_TARGET
, OP_SH_TARGET
); break;
10914 case 'j': USE_BITS (OP_MASK_EVAOFFSET
, OP_SH_EVAOFFSET
); break;
10917 as_bad (_("internal: bad mips opcode (unknown extension operand type `+%c'): %s %s"),
10918 c
, opc
->name
, opc
->args
);
10922 case '<': USE_BITS (OP_MASK_SHAMT
, OP_SH_SHAMT
); break;
10923 case '>': USE_BITS (OP_MASK_SHAMT
, OP_SH_SHAMT
); break;
10925 case 'B': USE_BITS (OP_MASK_CODE20
, OP_SH_CODE20
); break;
10926 case 'C': USE_BITS (OP_MASK_COPZ
, OP_SH_COPZ
); break;
10927 case 'D': USE_BITS (OP_MASK_FD
, OP_SH_FD
); break;
10928 case 'E': USE_BITS (OP_MASK_RT
, OP_SH_RT
); break;
10930 case 'G': USE_BITS (OP_MASK_RD
, OP_SH_RD
); break;
10931 case 'H': USE_BITS (OP_MASK_SEL
, OP_SH_SEL
); break;
10933 case 'J': USE_BITS (OP_MASK_CODE19
, OP_SH_CODE19
); break;
10934 case 'K': USE_BITS (OP_MASK_RD
, OP_SH_RD
); break;
10936 case 'M': USE_BITS (OP_MASK_CCC
, OP_SH_CCC
); break;
10937 case 'N': USE_BITS (OP_MASK_BCC
, OP_SH_BCC
); break;
10938 case 'O': USE_BITS (OP_MASK_ALN
, OP_SH_ALN
); break;
10939 case 'Q': USE_BITS (OP_MASK_VSEL
, OP_SH_VSEL
);
10940 USE_BITS (OP_MASK_FT
, OP_SH_FT
); break;
10941 case 'R': USE_BITS (OP_MASK_FR
, OP_SH_FR
); break;
10942 case 'S': USE_BITS (OP_MASK_FS
, OP_SH_FS
); break;
10943 case 'T': USE_BITS (OP_MASK_FT
, OP_SH_FT
); break;
10944 case 'V': USE_BITS (OP_MASK_FS
, OP_SH_FS
); break;
10945 case 'W': USE_BITS (OP_MASK_FT
, OP_SH_FT
); break;
10946 case 'X': USE_BITS (OP_MASK_FD
, OP_SH_FD
); break;
10947 case 'Y': USE_BITS (OP_MASK_FS
, OP_SH_FS
); break;
10948 case 'Z': USE_BITS (OP_MASK_FT
, OP_SH_FT
); break;
10949 case 'a': USE_BITS (OP_MASK_TARGET
, OP_SH_TARGET
); break;
10950 case 'b': USE_BITS (OP_MASK_RS
, OP_SH_RS
); break;
10951 case 'c': USE_BITS (OP_MASK_CODE
, OP_SH_CODE
); break;
10952 case 'd': USE_BITS (OP_MASK_RD
, OP_SH_RD
); break;
10954 case 'h': USE_BITS (OP_MASK_PREFX
, OP_SH_PREFX
); break;
10955 case 'i': USE_BITS (OP_MASK_IMMEDIATE
, OP_SH_IMMEDIATE
); break;
10956 case 'j': USE_BITS (OP_MASK_DELTA
, OP_SH_DELTA
); break;
10957 case 'k': USE_BITS (OP_MASK_CACHE
, OP_SH_CACHE
); break;
10959 case 'o': USE_BITS (OP_MASK_DELTA
, OP_SH_DELTA
); break;
10960 case 'p': USE_BITS (OP_MASK_DELTA
, OP_SH_DELTA
); break;
10961 case 'q': USE_BITS (OP_MASK_CODE2
, OP_SH_CODE2
); break;
10962 case 'r': USE_BITS (OP_MASK_RS
, OP_SH_RS
); break;
10963 case 's': USE_BITS (OP_MASK_RS
, OP_SH_RS
); break;
10964 case 't': USE_BITS (OP_MASK_RT
, OP_SH_RT
); break;
10965 case 'u': USE_BITS (OP_MASK_IMMEDIATE
, OP_SH_IMMEDIATE
); break;
10966 case 'v': USE_BITS (OP_MASK_RS
, OP_SH_RS
); break;
10967 case 'w': USE_BITS (OP_MASK_RT
, OP_SH_RT
); break;
10970 case 'P': USE_BITS (OP_MASK_PERFREG
, OP_SH_PERFREG
); break;
10971 case 'U': USE_BITS (OP_MASK_RD
, OP_SH_RD
);
10972 USE_BITS (OP_MASK_RT
, OP_SH_RT
); break;
10973 case 'e': USE_BITS (OP_MASK_VECBYTE
, OP_SH_VECBYTE
); break;
10974 case '%': USE_BITS (OP_MASK_VECALIGN
, OP_SH_VECALIGN
); break;
10977 case '1': USE_BITS (OP_MASK_STYPE
, OP_SH_STYPE
); break;
10978 case '2': USE_BITS (OP_MASK_BP
, OP_SH_BP
); break;
10979 case '3': USE_BITS (OP_MASK_SA3
, OP_SH_SA3
); break;
10980 case '4': USE_BITS (OP_MASK_SA4
, OP_SH_SA4
); break;
10981 case '5': USE_BITS (OP_MASK_IMM8
, OP_SH_IMM8
); break;
10982 case '6': USE_BITS (OP_MASK_RS
, OP_SH_RS
); break;
10983 case '7': USE_BITS (OP_MASK_DSPACC
, OP_SH_DSPACC
); break;
10984 case '8': USE_BITS (OP_MASK_WRDSP
, OP_SH_WRDSP
); break;
10985 case '9': USE_BITS (OP_MASK_DSPACC_S
, OP_SH_DSPACC_S
);break;
10986 case '0': USE_BITS (OP_MASK_DSPSFT
, OP_SH_DSPSFT
); break;
10987 case '\'': USE_BITS (OP_MASK_RDDSP
, OP_SH_RDDSP
); break;
10988 case ':': USE_BITS (OP_MASK_DSPSFT_7
, OP_SH_DSPSFT_7
);break;
10989 case '@': USE_BITS (OP_MASK_IMM10
, OP_SH_IMM10
); break;
10990 case '!': USE_BITS (OP_MASK_MT_U
, OP_SH_MT_U
); break;
10991 case '$': USE_BITS (OP_MASK_MT_H
, OP_SH_MT_H
); break;
10992 case '*': USE_BITS (OP_MASK_MTACC_T
, OP_SH_MTACC_T
); break;
10993 case '&': USE_BITS (OP_MASK_MTACC_D
, OP_SH_MTACC_D
); break;
10994 case '\\': USE_BITS (OP_MASK_3BITPOS
, OP_SH_3BITPOS
); break;
10995 case '~': USE_BITS (OP_MASK_OFFSET12
, OP_SH_OFFSET12
); break;
10996 case 'g': USE_BITS (OP_MASK_RD
, OP_SH_RD
); break;
10998 as_bad (_("internal: bad mips opcode (unknown operand type `%c'): %s %s"),
10999 c
, opc
->name
, opc
->args
);
11003 if (used_bits
!= 0xffffffff)
11005 as_bad (_("internal: bad mips opcode (bits 0x%lx undefined): %s %s"),
11006 ~used_bits
& 0xffffffff, opc
->name
, opc
->args
);
11012 /* For consistency checking, verify that the length implied matches the
11013 major opcode and that all bits are specified either by the match/mask
11014 part of the instruction definition, or by the operand list. */
11017 validate_micromips_insn (const struct mips_opcode
*opc
)
11019 unsigned long match
= opc
->match
;
11020 unsigned long mask
= opc
->mask
;
11021 const char *p
= opc
->args
;
11022 unsigned long insn_bits
;
11023 unsigned long used_bits
;
11024 unsigned long major
;
11025 unsigned int length
;
11029 if ((mask
& match
) != match
)
11031 as_bad (_("Internal error: bad microMIPS opcode (mask error): %s %s"),
11032 opc
->name
, opc
->args
);
11035 length
= micromips_insn_length (opc
);
11036 if (length
!= 2 && length
!= 4)
11038 as_bad (_("Internal error: bad microMIPS opcode (incorrect length: %u): "
11039 "%s %s"), length
, opc
->name
, opc
->args
);
11042 major
= match
>> (10 + 8 * (length
- 2));
11043 if ((length
== 2 && (major
& 7) != 1 && (major
& 6) != 2)
11044 || (length
== 4 && (major
& 7) != 0 && (major
& 4) != 4))
11046 as_bad (_("Internal error: bad microMIPS opcode "
11047 "(opcode/length mismatch): %s %s"), opc
->name
, opc
->args
);
11051 /* Shift piecewise to avoid an overflow where unsigned long is 32-bit. */
11052 insn_bits
= 1 << 4 * length
;
11053 insn_bits
<<= 4 * length
;
11056 #define USE_BITS(field) \
11057 (used_bits |= MICROMIPSOP_MASK_##field << MICROMIPSOP_SH_##field)
11068 case 'A': USE_BITS (EXTLSB
); break;
11069 case 'B': USE_BITS (INSMSB
); break;
11070 case 'C': USE_BITS (EXTMSBD
); break;
11071 case 'E': USE_BITS (EXTLSB
); break;
11072 case 'F': USE_BITS (INSMSB
); break;
11073 case 'G': USE_BITS (EXTMSBD
); break;
11074 case 'H': USE_BITS (EXTMSBD
); break;
11075 case 'i': USE_BITS (TARGET
); break;
11076 case 'j': USE_BITS (EVAOFFSET
); break;
11078 as_bad (_("Internal error: bad mips opcode "
11079 "(unknown extension operand type `%c%c'): %s %s"),
11080 e
, c
, opc
->name
, opc
->args
);
11088 case 'A': USE_BITS (IMMA
); break;
11089 case 'B': USE_BITS (IMMB
); break;
11090 case 'C': USE_BITS (IMMC
); break;
11091 case 'D': USE_BITS (IMMD
); break;
11092 case 'E': USE_BITS (IMME
); break;
11093 case 'F': USE_BITS (IMMF
); break;
11094 case 'G': USE_BITS (IMMG
); break;
11095 case 'H': USE_BITS (IMMH
); break;
11096 case 'I': USE_BITS (IMMI
); break;
11097 case 'J': USE_BITS (IMMJ
); break;
11098 case 'L': USE_BITS (IMML
); break;
11099 case 'M': USE_BITS (IMMM
); break;
11100 case 'N': USE_BITS (IMMN
); break;
11101 case 'O': USE_BITS (IMMO
); break;
11102 case 'P': USE_BITS (IMMP
); break;
11103 case 'Q': USE_BITS (IMMQ
); break;
11104 case 'U': USE_BITS (IMMU
); break;
11105 case 'W': USE_BITS (IMMW
); break;
11106 case 'X': USE_BITS (IMMX
); break;
11107 case 'Y': USE_BITS (IMMY
); break;
11110 case 'b': USE_BITS (MB
); break;
11111 case 'c': USE_BITS (MC
); break;
11112 case 'd': USE_BITS (MD
); break;
11113 case 'e': USE_BITS (ME
); break;
11114 case 'f': USE_BITS (MF
); break;
11115 case 'g': USE_BITS (MG
); break;
11116 case 'h': USE_BITS (MH
); break;
11117 case 'j': USE_BITS (MJ
); break;
11118 case 'l': USE_BITS (ML
); break;
11119 case 'm': USE_BITS (MM
); break;
11120 case 'n': USE_BITS (MN
); break;
11121 case 'p': USE_BITS (MP
); break;
11122 case 'q': USE_BITS (MQ
); break;
11130 as_bad (_("Internal error: bad mips opcode "
11131 "(unknown extension operand type `%c%c'): %s %s"),
11132 e
, c
, opc
->name
, opc
->args
);
11136 case '.': USE_BITS (OFFSET10
); break;
11137 case '1': USE_BITS (STYPE
); break;
11138 case '2': USE_BITS (BP
); break;
11139 case '3': USE_BITS (SA3
); break;
11140 case '4': USE_BITS (SA4
); break;
11141 case '5': USE_BITS (IMM8
); break;
11142 case '6': USE_BITS (RS
); break;
11143 case '7': USE_BITS (DSPACC
); break;
11144 case '8': USE_BITS (WRDSP
); break;
11145 case '0': USE_BITS (DSPSFT
); break;
11146 case '<': USE_BITS (SHAMT
); break;
11147 case '>': USE_BITS (SHAMT
); break;
11148 case '@': USE_BITS (IMM10
); break;
11149 case 'B': USE_BITS (CODE10
); break;
11150 case 'C': USE_BITS (COPZ
); break;
11151 case 'D': USE_BITS (FD
); break;
11152 case 'E': USE_BITS (RT
); break;
11153 case 'G': USE_BITS (RS
); break;
11154 case 'H': USE_BITS (SEL
); break;
11155 case 'K': USE_BITS (RS
); break;
11156 case 'M': USE_BITS (CCC
); break;
11157 case 'N': USE_BITS (BCC
); break;
11158 case 'R': USE_BITS (FR
); break;
11159 case 'S': USE_BITS (FS
); break;
11160 case 'T': USE_BITS (FT
); break;
11161 case 'V': USE_BITS (FS
); break;
11162 case '\\': USE_BITS (3BITPOS
); break;
11163 case '^': USE_BITS (RD
); break;
11164 case 'a': USE_BITS (TARGET
); break;
11165 case 'b': USE_BITS (RS
); break;
11166 case 'c': USE_BITS (CODE
); break;
11167 case 'd': USE_BITS (RD
); break;
11168 case 'h': USE_BITS (PREFX
); break;
11169 case 'i': USE_BITS (IMMEDIATE
); break;
11170 case 'j': USE_BITS (DELTA
); break;
11171 case 'k': USE_BITS (CACHE
); break;
11172 case 'n': USE_BITS (RT
); break;
11173 case 'o': USE_BITS (DELTA
); break;
11174 case 'p': USE_BITS (DELTA
); break;
11175 case 'q': USE_BITS (CODE2
); break;
11176 case 'r': USE_BITS (RS
); break;
11177 case 's': USE_BITS (RS
); break;
11178 case 't': USE_BITS (RT
); break;
11179 case 'u': USE_BITS (IMMEDIATE
); break;
11180 case 'v': USE_BITS (RS
); break;
11181 case 'w': USE_BITS (RT
); break;
11182 case 'y': USE_BITS (RS3
); break;
11184 case '|': USE_BITS (TRAP
); break;
11185 case '~': USE_BITS (OFFSET12
); break;
11187 as_bad (_("Internal error: bad microMIPS opcode "
11188 "(unknown operand type `%c'): %s %s"),
11189 c
, opc
->name
, opc
->args
);
11193 if (used_bits
!= insn_bits
)
11195 if (~used_bits
& insn_bits
)
11196 as_bad (_("Internal error: bad microMIPS opcode "
11197 "(bits 0x%lx undefined): %s %s"),
11198 ~used_bits
& insn_bits
, opc
->name
, opc
->args
);
11199 if (used_bits
& ~insn_bits
)
11200 as_bad (_("Internal error: bad microMIPS opcode "
11201 "(bits 0x%lx defined): %s %s"),
11202 used_bits
& ~insn_bits
, opc
->name
, opc
->args
);
11208 /* UDI immediates. */
11209 struct mips_immed
{
11211 unsigned int shift
;
11212 unsigned long mask
;
11216 static const struct mips_immed mips_immed
[] = {
11217 { '1', OP_SH_UDI1
, OP_MASK_UDI1
, 0},
11218 { '2', OP_SH_UDI2
, OP_MASK_UDI2
, 0},
11219 { '3', OP_SH_UDI3
, OP_MASK_UDI3
, 0},
11220 { '4', OP_SH_UDI4
, OP_MASK_UDI4
, 0},
11224 /* Check whether an odd floating-point register is allowed. */
11226 mips_oddfpreg_ok (const struct mips_opcode
*insn
, int argnum
)
11228 const char *s
= insn
->name
;
11230 if (insn
->pinfo
== INSN_MACRO
)
11231 /* Let a macro pass, we'll catch it later when it is expanded. */
11234 if (ISA_HAS_ODD_SINGLE_FPR (mips_opts
.isa
) || (mips_opts
.arch
== CPU_R5900
))
11236 /* Allow odd registers for single-precision ops. */
11237 switch (insn
->pinfo
& (FP_S
| FP_D
))
11241 return 1; /* both single precision - ok */
11243 return 0; /* both double precision - fail */
11248 /* Cvt.w.x and cvt.x.w allow an odd register for a 'w' or 's' operand. */
11249 s
= strchr (insn
->name
, '.');
11251 s
= s
!= NULL
? strchr (s
+ 1, '.') : NULL
;
11252 return (s
!= NULL
&& (s
[1] == 'w' || s
[1] == 's'));
11255 /* Single-precision coprocessor loads and moves are OK too. */
11256 if ((insn
->pinfo
& FP_S
)
11257 && (insn
->pinfo
& (INSN_COPROC_MEMORY_DELAY
| INSN_STORE_MEMORY
11258 | INSN_LOAD_COPROC_DELAY
| INSN_COPROC_MOVE_DELAY
)))
11264 /* Check if EXPR is a constant between MIN (inclusive) and MAX (exclusive)
11265 taking bits from BIT up. */
11267 expr_const_in_range (expressionS
*ep
, offsetT min
, offsetT max
, int bit
)
11269 return (ep
->X_op
== O_constant
11270 && (ep
->X_add_number
& ((1 << bit
) - 1)) == 0
11271 && ep
->X_add_number
>= min
<< bit
11272 && ep
->X_add_number
< max
<< bit
);
11275 /* This routine assembles an instruction into its binary format. As a
11276 side effect, it sets one of the global variables imm_reloc or
11277 offset_reloc to the type of relocation to do if one of the operands
11278 is an address expression. */
11281 mips_ip (char *str
, struct mips_cl_insn
*ip
)
11283 bfd_boolean wrong_delay_slot_insns
= FALSE
;
11284 bfd_boolean need_delay_slot_ok
= TRUE
;
11285 struct mips_opcode
*firstinsn
= NULL
;
11286 const struct mips_opcode
*past
;
11287 struct hash_control
*hash
;
11291 struct mips_opcode
*insn
;
11293 unsigned int regno
, regno2
;
11294 unsigned int lastregno
;
11295 unsigned int destregno
= 0;
11296 unsigned int lastpos
= 0;
11297 unsigned int limlo
, limhi
;
11300 offsetT min_range
, max_range
;
11304 unsigned int rtype
;
11310 if (mips_opts
.micromips
)
11312 hash
= micromips_op_hash
;
11313 past
= µmips_opcodes
[bfd_micromips_num_opcodes
];
11318 past
= &mips_opcodes
[NUMOPCODES
];
11320 forced_insn_length
= 0;
11323 /* We first try to match an instruction up to a space or to the end. */
11324 for (end
= 0; str
[end
] != '\0' && !ISSPACE (str
[end
]); end
++)
11327 /* Make a copy of the instruction so that we can fiddle with it. */
11328 name
= alloca (end
+ 1);
11329 memcpy (name
, str
, end
);
11334 insn
= (struct mips_opcode
*) hash_find (hash
, name
);
11336 if (insn
!= NULL
|| !mips_opts
.micromips
)
11338 if (forced_insn_length
)
11341 /* See if there's an instruction size override suffix,
11342 either `16' or `32', at the end of the mnemonic proper,
11343 that defines the operation, i.e. before the first `.'
11344 character if any. Strip it and retry. */
11345 dot
= strchr (name
, '.');
11346 opend
= dot
!= NULL
? dot
- name
: end
;
11349 if (name
[opend
- 2] == '1' && name
[opend
- 1] == '6')
11350 forced_insn_length
= 2;
11351 else if (name
[opend
- 2] == '3' && name
[opend
- 1] == '2')
11352 forced_insn_length
= 4;
11355 memcpy (name
+ opend
- 2, name
+ opend
, end
- opend
+ 1);
11359 insn_error
= _("Unrecognized opcode");
11363 /* For microMIPS instructions placed in a fixed-length branch delay slot
11364 we make up to two passes over the relevant fragment of the opcode
11365 table. First we try instructions that meet the delay slot's length
11366 requirement. If none matched, then we retry with the remaining ones
11367 and if one matches, then we use it and then issue an appropriate
11368 warning later on. */
11369 argsStart
= s
= str
+ end
;
11372 bfd_boolean delay_slot_ok
;
11373 bfd_boolean size_ok
;
11376 gas_assert (strcmp (insn
->name
, name
) == 0);
11378 ok
= is_opcode_valid (insn
);
11379 size_ok
= is_size_valid (insn
);
11380 delay_slot_ok
= is_delay_slot_valid (insn
);
11381 if (!delay_slot_ok
&& !wrong_delay_slot_insns
)
11384 wrong_delay_slot_insns
= TRUE
;
11386 if (!ok
|| !size_ok
|| delay_slot_ok
!= need_delay_slot_ok
)
11388 static char buf
[256];
11390 if (insn
+ 1 < past
&& strcmp (insn
->name
, insn
[1].name
) == 0)
11395 if (wrong_delay_slot_insns
&& need_delay_slot_ok
)
11397 gas_assert (firstinsn
);
11398 need_delay_slot_ok
= FALSE
;
11408 sprintf (buf
, _("Opcode not supported on this processor: %s (%s)"),
11409 mips_cpu_info_from_arch (mips_opts
.arch
)->name
,
11410 mips_cpu_info_from_isa (mips_opts
.isa
)->name
);
11411 else if (mips_opts
.insn32
)
11412 sprintf (buf
, _("Opcode not supported in the `insn32' mode"));
11414 sprintf (buf
, _("Unrecognized %u-bit version of microMIPS opcode"),
11415 8 * forced_insn_length
);
11421 create_insn (ip
, insn
);
11424 lastregno
= 0xffffffff;
11425 for (args
= insn
->args
;; ++args
)
11429 s
+= strspn (s
, " \t");
11433 case '\0': /* end of args */
11439 /* DSP 2-bit unsigned immediate in bit 11 (for standard MIPS
11440 code) or 14 (for microMIPS code). */
11441 my_getExpression (&imm_expr
, s
);
11442 check_absolute_expr (ip
, &imm_expr
);
11443 if ((unsigned long) imm_expr
.X_add_number
!= 1
11444 && (unsigned long) imm_expr
.X_add_number
!= 3)
11446 as_bad (_("BALIGN immediate not 1 or 3 (%lu)"),
11447 (unsigned long) imm_expr
.X_add_number
);
11449 INSERT_OPERAND (mips_opts
.micromips
,
11450 BP
, *ip
, imm_expr
.X_add_number
);
11451 imm_expr
.X_op
= O_absent
;
11456 /* DSP 3-bit unsigned immediate in bit 21 (for standard MIPS
11457 code) or 13 (for microMIPS code). */
11459 unsigned long mask
= (mips_opts
.micromips
11460 ? MICROMIPSOP_MASK_SA3
: OP_MASK_SA3
);
11462 my_getExpression (&imm_expr
, s
);
11463 check_absolute_expr (ip
, &imm_expr
);
11464 if ((unsigned long) imm_expr
.X_add_number
> mask
)
11465 as_bad (_("DSP immediate not in range 0..%lu (%lu)"),
11466 mask
, (unsigned long) imm_expr
.X_add_number
);
11467 INSERT_OPERAND (mips_opts
.micromips
,
11468 SA3
, *ip
, imm_expr
.X_add_number
);
11469 imm_expr
.X_op
= O_absent
;
11475 /* DSP 4-bit unsigned immediate in bit 21 (for standard MIPS
11476 code) or 12 (for microMIPS code). */
11478 unsigned long mask
= (mips_opts
.micromips
11479 ? MICROMIPSOP_MASK_SA4
: OP_MASK_SA4
);
11481 my_getExpression (&imm_expr
, s
);
11482 check_absolute_expr (ip
, &imm_expr
);
11483 if ((unsigned long) imm_expr
.X_add_number
> mask
)
11484 as_bad (_("DSP immediate not in range 0..%lu (%lu)"),
11485 mask
, (unsigned long) imm_expr
.X_add_number
);
11486 INSERT_OPERAND (mips_opts
.micromips
,
11487 SA4
, *ip
, imm_expr
.X_add_number
);
11488 imm_expr
.X_op
= O_absent
;
11494 /* DSP 8-bit unsigned immediate in bit 16 (for standard MIPS
11495 code) or 13 (for microMIPS code). */
11497 unsigned long mask
= (mips_opts
.micromips
11498 ? MICROMIPSOP_MASK_IMM8
: OP_MASK_IMM8
);
11500 my_getExpression (&imm_expr
, s
);
11501 check_absolute_expr (ip
, &imm_expr
);
11502 if ((unsigned long) imm_expr
.X_add_number
> mask
)
11503 as_bad (_("DSP immediate not in range 0..%lu (%lu)"),
11504 mask
, (unsigned long) imm_expr
.X_add_number
);
11505 INSERT_OPERAND (mips_opts
.micromips
,
11506 IMM8
, *ip
, imm_expr
.X_add_number
);
11507 imm_expr
.X_op
= O_absent
;
11513 /* DSP 5-bit unsigned immediate in bit 21 (for standard MIPS
11514 code) or 16 (for microMIPS code). */
11516 unsigned long mask
= (mips_opts
.micromips
11517 ? MICROMIPSOP_MASK_RS
: OP_MASK_RS
);
11519 my_getExpression (&imm_expr
, s
);
11520 check_absolute_expr (ip
, &imm_expr
);
11521 if ((unsigned long) imm_expr
.X_add_number
> mask
)
11522 as_bad (_("DSP immediate not in range 0..%lu (%lu)"),
11523 mask
, (unsigned long) imm_expr
.X_add_number
);
11524 INSERT_OPERAND (mips_opts
.micromips
,
11525 RS
, *ip
, imm_expr
.X_add_number
);
11526 imm_expr
.X_op
= O_absent
;
11532 /* Four DSP accumulators in bit 11 (for standard MIPS code)
11533 or 14 (for microMIPS code). */
11534 if (s
[0] == '$' && s
[1] == 'a' && s
[2] == 'c'
11535 && s
[3] >= '0' && s
[3] <= '3')
11537 regno
= s
[3] - '0';
11539 INSERT_OPERAND (mips_opts
.micromips
, DSPACC
, *ip
, regno
);
11543 as_bad (_("Invalid dsp acc register"));
11547 /* DSP 6-bit unsigned immediate in bit 11 (for standard MIPS
11548 code) or 14 (for microMIPS code). */
11550 unsigned long mask
= (mips_opts
.micromips
11551 ? MICROMIPSOP_MASK_WRDSP
11554 my_getExpression (&imm_expr
, s
);
11555 check_absolute_expr (ip
, &imm_expr
);
11556 if ((unsigned long) imm_expr
.X_add_number
> mask
)
11557 as_bad (_("DSP immediate not in range 0..%lu (%lu)"),
11558 mask
, (unsigned long) imm_expr
.X_add_number
);
11559 INSERT_OPERAND (mips_opts
.micromips
,
11560 WRDSP
, *ip
, imm_expr
.X_add_number
);
11561 imm_expr
.X_op
= O_absent
;
11566 case '9': /* Four DSP accumulators in bits 21,22. */
11567 gas_assert (!mips_opts
.micromips
);
11568 if (s
[0] == '$' && s
[1] == 'a' && s
[2] == 'c'
11569 && s
[3] >= '0' && s
[3] <= '3')
11571 regno
= s
[3] - '0';
11573 INSERT_OPERAND (0, DSPACC_S
, *ip
, regno
);
11577 as_bad (_("Invalid dsp acc register"));
11581 /* DSP 6-bit signed immediate in bit 20 (for standard MIPS
11582 code) or 16 (for microMIPS code). */
11584 long mask
= (mips_opts
.micromips
11585 ? MICROMIPSOP_MASK_DSPSFT
: OP_MASK_DSPSFT
);
11587 my_getExpression (&imm_expr
, s
);
11588 check_absolute_expr (ip
, &imm_expr
);
11589 min_range
= -((mask
+ 1) >> 1);
11590 max_range
= ((mask
+ 1) >> 1) - 1;
11591 if (imm_expr
.X_add_number
< min_range
11592 || imm_expr
.X_add_number
> max_range
)
11593 as_bad (_("DSP immediate not in range %ld..%ld (%ld)"),
11594 (long) min_range
, (long) max_range
,
11595 (long) imm_expr
.X_add_number
);
11596 INSERT_OPERAND (mips_opts
.micromips
,
11597 DSPSFT
, *ip
, imm_expr
.X_add_number
);
11598 imm_expr
.X_op
= O_absent
;
11603 case '\'': /* DSP 6-bit unsigned immediate in bit 16. */
11604 gas_assert (!mips_opts
.micromips
);
11605 my_getExpression (&imm_expr
, s
);
11606 check_absolute_expr (ip
, &imm_expr
);
11607 if (imm_expr
.X_add_number
& ~OP_MASK_RDDSP
)
11609 as_bad (_("DSP immediate not in range 0..%d (%lu)"),
11611 (unsigned long) imm_expr
.X_add_number
);
11613 INSERT_OPERAND (0, RDDSP
, *ip
, imm_expr
.X_add_number
);
11614 imm_expr
.X_op
= O_absent
;
11618 case ':': /* DSP 7-bit signed immediate in bit 19. */
11619 gas_assert (!mips_opts
.micromips
);
11620 my_getExpression (&imm_expr
, s
);
11621 check_absolute_expr (ip
, &imm_expr
);
11622 min_range
= -((OP_MASK_DSPSFT_7
+ 1) >> 1);
11623 max_range
= ((OP_MASK_DSPSFT_7
+ 1) >> 1) - 1;
11624 if (imm_expr
.X_add_number
< min_range
||
11625 imm_expr
.X_add_number
> max_range
)
11627 as_bad (_("DSP immediate not in range %ld..%ld (%ld)"),
11628 (long) min_range
, (long) max_range
,
11629 (long) imm_expr
.X_add_number
);
11631 INSERT_OPERAND (0, DSPSFT_7
, *ip
, imm_expr
.X_add_number
);
11632 imm_expr
.X_op
= O_absent
;
11636 case '@': /* DSP 10-bit signed immediate in bit 16. */
11638 long mask
= (mips_opts
.micromips
11639 ? MICROMIPSOP_MASK_IMM10
: OP_MASK_IMM10
);
11641 my_getExpression (&imm_expr
, s
);
11642 check_absolute_expr (ip
, &imm_expr
);
11643 min_range
= -((mask
+ 1) >> 1);
11644 max_range
= ((mask
+ 1) >> 1) - 1;
11645 if (imm_expr
.X_add_number
< min_range
11646 || imm_expr
.X_add_number
> max_range
)
11647 as_bad (_("DSP immediate not in range %ld..%ld (%ld)"),
11648 (long) min_range
, (long) max_range
,
11649 (long) imm_expr
.X_add_number
);
11650 INSERT_OPERAND (mips_opts
.micromips
,
11651 IMM10
, *ip
, imm_expr
.X_add_number
);
11652 imm_expr
.X_op
= O_absent
;
11657 case '^': /* DSP 5-bit unsigned immediate in bit 11. */
11658 gas_assert (mips_opts
.micromips
);
11659 my_getExpression (&imm_expr
, s
);
11660 check_absolute_expr (ip
, &imm_expr
);
11661 if (imm_expr
.X_add_number
& ~MICROMIPSOP_MASK_RD
)
11662 as_bad (_("DSP immediate not in range 0..%d (%lu)"),
11663 MICROMIPSOP_MASK_RD
,
11664 (unsigned long) imm_expr
.X_add_number
);
11665 INSERT_OPERAND (1, RD
, *ip
, imm_expr
.X_add_number
);
11666 imm_expr
.X_op
= O_absent
;
11670 case '!': /* MT usermode flag bit. */
11671 gas_assert (!mips_opts
.micromips
);
11672 my_getExpression (&imm_expr
, s
);
11673 check_absolute_expr (ip
, &imm_expr
);
11674 if (imm_expr
.X_add_number
& ~OP_MASK_MT_U
)
11675 as_bad (_("MT usermode bit not 0 or 1 (%lu)"),
11676 (unsigned long) imm_expr
.X_add_number
);
11677 INSERT_OPERAND (0, MT_U
, *ip
, imm_expr
.X_add_number
);
11678 imm_expr
.X_op
= O_absent
;
11682 case '$': /* MT load high flag bit. */
11683 gas_assert (!mips_opts
.micromips
);
11684 my_getExpression (&imm_expr
, s
);
11685 check_absolute_expr (ip
, &imm_expr
);
11686 if (imm_expr
.X_add_number
& ~OP_MASK_MT_H
)
11687 as_bad (_("MT load high bit not 0 or 1 (%lu)"),
11688 (unsigned long) imm_expr
.X_add_number
);
11689 INSERT_OPERAND (0, MT_H
, *ip
, imm_expr
.X_add_number
);
11690 imm_expr
.X_op
= O_absent
;
11694 case '*': /* Four DSP accumulators in bits 18,19. */
11695 gas_assert (!mips_opts
.micromips
);
11696 if (s
[0] == '$' && s
[1] == 'a' && s
[2] == 'c' &&
11697 s
[3] >= '0' && s
[3] <= '3')
11699 regno
= s
[3] - '0';
11701 INSERT_OPERAND (0, MTACC_T
, *ip
, regno
);
11705 as_bad (_("Invalid dsp/smartmips acc register"));
11708 case '&': /* Four DSP accumulators in bits 13,14. */
11709 gas_assert (!mips_opts
.micromips
);
11710 if (s
[0] == '$' && s
[1] == 'a' && s
[2] == 'c' &&
11711 s
[3] >= '0' && s
[3] <= '3')
11713 regno
= s
[3] - '0';
11715 INSERT_OPERAND (0, MTACC_D
, *ip
, regno
);
11719 as_bad (_("Invalid dsp/smartmips acc register"));
11722 case '\\': /* 3-bit bit position. */
11724 unsigned long mask
= (mips_opts
.micromips
11725 ? MICROMIPSOP_MASK_3BITPOS
11726 : OP_MASK_3BITPOS
);
11728 my_getExpression (&imm_expr
, s
);
11729 check_absolute_expr (ip
, &imm_expr
);
11730 if ((unsigned long) imm_expr
.X_add_number
> mask
)
11731 as_warn (_("Bit position for %s not in range 0..%lu (%lu)"),
11733 mask
, (unsigned long) imm_expr
.X_add_number
);
11734 INSERT_OPERAND (mips_opts
.micromips
,
11735 3BITPOS
, *ip
, imm_expr
.X_add_number
);
11736 imm_expr
.X_op
= O_absent
;
11750 INSERT_OPERAND (mips_opts
.micromips
, RS
, *ip
, lastregno
);
11754 INSERT_OPERAND (mips_opts
.micromips
, RT
, *ip
, lastregno
);
11758 gas_assert (!mips_opts
.micromips
);
11759 INSERT_OPERAND (0, FT
, *ip
, lastregno
);
11763 INSERT_OPERAND (mips_opts
.micromips
, FS
, *ip
, lastregno
);
11769 /* Handle optional base register.
11770 Either the base register is omitted or
11771 we must have a left paren. */
11772 /* This is dependent on the next operand specifier
11773 is a base register specification. */
11774 gas_assert (args
[1] == 'b'
11775 || (mips_opts
.micromips
11777 && (args
[2] == 'l' || args
[2] == 'n'
11778 || args
[2] == 's' || args
[2] == 'a')));
11779 if (*s
== '\0' && args
[1] == 'b')
11781 /* Fall through. */
11783 case ')': /* These must match exactly. */
11788 case '[': /* These must match exactly. */
11790 gas_assert (!mips_opts
.micromips
);
11795 case '+': /* Opcode extension character. */
11798 case '1': /* UDI immediates. */
11802 gas_assert (!mips_opts
.micromips
);
11804 const struct mips_immed
*imm
= mips_immed
;
11806 while (imm
->type
&& imm
->type
!= *args
)
11810 my_getExpression (&imm_expr
, s
);
11811 check_absolute_expr (ip
, &imm_expr
);
11812 if ((unsigned long) imm_expr
.X_add_number
& ~imm
->mask
)
11814 as_warn (_("Illegal %s number (%lu, 0x%lx)"),
11815 imm
->desc
? imm
->desc
: ip
->insn_mo
->name
,
11816 (unsigned long) imm_expr
.X_add_number
,
11817 (unsigned long) imm_expr
.X_add_number
);
11818 imm_expr
.X_add_number
&= imm
->mask
;
11820 ip
->insn_opcode
|= ((unsigned long) imm_expr
.X_add_number
11822 imm_expr
.X_op
= O_absent
;
11827 case 'J': /* 10-bit hypcall code. */
11828 gas_assert (!mips_opts
.micromips
);
11830 unsigned long mask
= OP_MASK_CODE10
;
11832 my_getExpression (&imm_expr
, s
);
11833 check_absolute_expr (ip
, &imm_expr
);
11834 if ((unsigned long) imm_expr
.X_add_number
> mask
)
11835 as_warn (_("Code for %s not in range 0..%lu (%lu)"),
11837 mask
, (unsigned long) imm_expr
.X_add_number
);
11838 INSERT_OPERAND (0, CODE10
, *ip
, imm_expr
.X_add_number
);
11839 imm_expr
.X_op
= O_absent
;
11844 case 'A': /* ins/ext position, becomes LSB. */
11853 my_getExpression (&imm_expr
, s
);
11854 check_absolute_expr (ip
, &imm_expr
);
11855 if ((unsigned long) imm_expr
.X_add_number
< limlo
11856 || (unsigned long) imm_expr
.X_add_number
> limhi
)
11858 as_bad (_("Improper position (%lu)"),
11859 (unsigned long) imm_expr
.X_add_number
);
11860 imm_expr
.X_add_number
= limlo
;
11862 lastpos
= imm_expr
.X_add_number
;
11863 INSERT_OPERAND (mips_opts
.micromips
,
11864 EXTLSB
, *ip
, imm_expr
.X_add_number
);
11865 imm_expr
.X_op
= O_absent
;
11869 case 'B': /* ins size, becomes MSB. */
11878 my_getExpression (&imm_expr
, s
);
11879 check_absolute_expr (ip
, &imm_expr
);
11880 /* Check for negative input so that small negative numbers
11881 will not succeed incorrectly. The checks against
11882 (pos+size) transitively check "size" itself,
11883 assuming that "pos" is reasonable. */
11884 if ((long) imm_expr
.X_add_number
< 0
11885 || ((unsigned long) imm_expr
.X_add_number
11887 || ((unsigned long) imm_expr
.X_add_number
11888 + lastpos
) > limhi
)
11890 as_bad (_("Improper insert size (%lu, position %lu)"),
11891 (unsigned long) imm_expr
.X_add_number
,
11892 (unsigned long) lastpos
);
11893 imm_expr
.X_add_number
= limlo
- lastpos
;
11895 INSERT_OPERAND (mips_opts
.micromips
, INSMSB
, *ip
,
11896 lastpos
+ imm_expr
.X_add_number
- 1);
11897 imm_expr
.X_op
= O_absent
;
11901 case 'C': /* ext size, becomes MSBD. */
11917 my_getExpression (&imm_expr
, s
);
11918 check_absolute_expr (ip
, &imm_expr
);
11919 /* The checks against (pos+size) don't transitively check
11920 "size" itself, assuming that "pos" is reasonable.
11921 We also need to check the lower bound of "size". */
11922 if ((long) imm_expr
.X_add_number
< sizelo
11923 || ((unsigned long) imm_expr
.X_add_number
11925 || ((unsigned long) imm_expr
.X_add_number
11926 + lastpos
) > limhi
)
11928 as_bad (_("Improper extract size (%lu, position %lu)"),
11929 (unsigned long) imm_expr
.X_add_number
,
11930 (unsigned long) lastpos
);
11931 imm_expr
.X_add_number
= limlo
- lastpos
;
11933 INSERT_OPERAND (mips_opts
.micromips
,
11934 EXTMSBD
, *ip
, imm_expr
.X_add_number
- 1);
11935 imm_expr
.X_op
= O_absent
;
11940 /* "+I" is like "I", except that imm2_expr is used. */
11941 my_getExpression (&imm2_expr
, s
);
11942 if (imm2_expr
.X_op
!= O_big
11943 && imm2_expr
.X_op
!= O_constant
)
11944 insn_error
= _("absolute expression required");
11945 if (HAVE_32BIT_GPRS
)
11946 normalize_constant_expr (&imm2_expr
);
11950 case 't': /* Coprocessor register number. */
11951 gas_assert (!mips_opts
.micromips
);
11952 if (s
[0] == '$' && ISDIGIT (s
[1]))
11962 while (ISDIGIT (*s
));
11964 as_bad (_("Invalid register number (%d)"), regno
);
11967 INSERT_OPERAND (0, RT
, *ip
, regno
);
11972 as_bad (_("Invalid coprocessor 0 register number"));
11976 /* bbit[01] and bbit[01]32 bit index. Give error if index
11977 is not in the valid range. */
11978 gas_assert (!mips_opts
.micromips
);
11979 my_getExpression (&imm_expr
, s
);
11980 check_absolute_expr (ip
, &imm_expr
);
11981 if ((unsigned) imm_expr
.X_add_number
> 31)
11983 as_bad (_("Improper bit index (%lu)"),
11984 (unsigned long) imm_expr
.X_add_number
);
11985 imm_expr
.X_add_number
= 0;
11987 INSERT_OPERAND (0, BBITIND
, *ip
, imm_expr
.X_add_number
);
11988 imm_expr
.X_op
= O_absent
;
11993 /* bbit[01] bit index when bbit is used but we generate
11994 bbit[01]32 because the index is over 32. Move to the
11995 next candidate if index is not in the valid range. */
11996 gas_assert (!mips_opts
.micromips
);
11997 my_getExpression (&imm_expr
, s
);
11998 check_absolute_expr (ip
, &imm_expr
);
11999 if ((unsigned) imm_expr
.X_add_number
< 32
12000 || (unsigned) imm_expr
.X_add_number
> 63)
12002 INSERT_OPERAND (0, BBITIND
, *ip
, imm_expr
.X_add_number
- 32);
12003 imm_expr
.X_op
= O_absent
;
12008 /* cins, cins32, exts and exts32 position field. Give error
12009 if it's not in the valid range. */
12010 gas_assert (!mips_opts
.micromips
);
12011 my_getExpression (&imm_expr
, s
);
12012 check_absolute_expr (ip
, &imm_expr
);
12013 if ((unsigned) imm_expr
.X_add_number
> 31)
12015 as_bad (_("Improper position (%lu)"),
12016 (unsigned long) imm_expr
.X_add_number
);
12017 imm_expr
.X_add_number
= 0;
12019 /* Make the pos explicit to simplify +S. */
12020 lastpos
= imm_expr
.X_add_number
+ 32;
12021 INSERT_OPERAND (0, CINSPOS
, *ip
, imm_expr
.X_add_number
);
12022 imm_expr
.X_op
= O_absent
;
12027 /* cins, cins32, exts and exts32 position field. Move to
12028 the next candidate if it's not in the valid range. */
12029 gas_assert (!mips_opts
.micromips
);
12030 my_getExpression (&imm_expr
, s
);
12031 check_absolute_expr (ip
, &imm_expr
);
12032 if ((unsigned) imm_expr
.X_add_number
< 32
12033 || (unsigned) imm_expr
.X_add_number
> 63)
12035 lastpos
= imm_expr
.X_add_number
;
12036 INSERT_OPERAND (0, CINSPOS
, *ip
, imm_expr
.X_add_number
- 32);
12037 imm_expr
.X_op
= O_absent
;
12042 /* cins and exts length-minus-one field. */
12043 gas_assert (!mips_opts
.micromips
);
12044 my_getExpression (&imm_expr
, s
);
12045 check_absolute_expr (ip
, &imm_expr
);
12046 if ((unsigned long) imm_expr
.X_add_number
> 31)
12048 as_bad (_("Improper size (%lu)"),
12049 (unsigned long) imm_expr
.X_add_number
);
12050 imm_expr
.X_add_number
= 0;
12052 INSERT_OPERAND (0, CINSLM1
, *ip
, imm_expr
.X_add_number
);
12053 imm_expr
.X_op
= O_absent
;
12058 /* cins32/exts32 and cins/exts aliasing cint32/exts32
12059 length-minus-one field. */
12060 gas_assert (!mips_opts
.micromips
);
12061 my_getExpression (&imm_expr
, s
);
12062 check_absolute_expr (ip
, &imm_expr
);
12063 if ((long) imm_expr
.X_add_number
< 0
12064 || (unsigned long) imm_expr
.X_add_number
+ lastpos
> 63)
12066 as_bad (_("Improper size (%lu)"),
12067 (unsigned long) imm_expr
.X_add_number
);
12068 imm_expr
.X_add_number
= 0;
12070 INSERT_OPERAND (0, CINSLM1
, *ip
, imm_expr
.X_add_number
);
12071 imm_expr
.X_op
= O_absent
;
12076 /* seqi/snei immediate field. */
12077 gas_assert (!mips_opts
.micromips
);
12078 my_getExpression (&imm_expr
, s
);
12079 check_absolute_expr (ip
, &imm_expr
);
12080 if ((long) imm_expr
.X_add_number
< -512
12081 || (long) imm_expr
.X_add_number
>= 512)
12083 as_bad (_("Improper immediate (%ld)"),
12084 (long) imm_expr
.X_add_number
);
12085 imm_expr
.X_add_number
= 0;
12087 INSERT_OPERAND (0, SEQI
, *ip
, imm_expr
.X_add_number
);
12088 imm_expr
.X_op
= O_absent
;
12092 case 'a': /* 8-bit signed offset in bit 6 */
12093 gas_assert (!mips_opts
.micromips
);
12094 my_getExpression (&imm_expr
, s
);
12095 check_absolute_expr (ip
, &imm_expr
);
12096 min_range
= -((OP_MASK_OFFSET_A
+ 1) >> 1);
12097 max_range
= ((OP_MASK_OFFSET_A
+ 1) >> 1) - 1;
12098 if (imm_expr
.X_add_number
< min_range
12099 || imm_expr
.X_add_number
> max_range
)
12101 as_bad (_("Offset not in range %ld..%ld (%ld)"),
12102 (long) min_range
, (long) max_range
,
12103 (long) imm_expr
.X_add_number
);
12105 INSERT_OPERAND (0, OFFSET_A
, *ip
, imm_expr
.X_add_number
);
12106 imm_expr
.X_op
= O_absent
;
12110 case 'b': /* 8-bit signed offset in bit 3 */
12111 gas_assert (!mips_opts
.micromips
);
12112 my_getExpression (&imm_expr
, s
);
12113 check_absolute_expr (ip
, &imm_expr
);
12114 min_range
= -((OP_MASK_OFFSET_B
+ 1) >> 1);
12115 max_range
= ((OP_MASK_OFFSET_B
+ 1) >> 1) - 1;
12116 if (imm_expr
.X_add_number
< min_range
12117 || imm_expr
.X_add_number
> max_range
)
12119 as_bad (_("Offset not in range %ld..%ld (%ld)"),
12120 (long) min_range
, (long) max_range
,
12121 (long) imm_expr
.X_add_number
);
12123 INSERT_OPERAND (0, OFFSET_B
, *ip
, imm_expr
.X_add_number
);
12124 imm_expr
.X_op
= O_absent
;
12128 case 'c': /* 9-bit signed offset in bit 6 */
12129 gas_assert (!mips_opts
.micromips
);
12130 my_getExpression (&imm_expr
, s
);
12131 check_absolute_expr (ip
, &imm_expr
);
12132 min_range
= -((OP_MASK_OFFSET_C
+ 1) >> 1);
12133 max_range
= ((OP_MASK_OFFSET_C
+ 1) >> 1) - 1;
12134 /* We check the offset range before adjusted. */
12137 if (imm_expr
.X_add_number
< min_range
12138 || imm_expr
.X_add_number
> max_range
)
12140 as_bad (_("Offset not in range %ld..%ld (%ld)"),
12141 (long) min_range
, (long) max_range
,
12142 (long) imm_expr
.X_add_number
);
12144 if (imm_expr
.X_add_number
& 0xf)
12146 as_bad (_("Offset not 16 bytes alignment (%ld)"),
12147 (long) imm_expr
.X_add_number
);
12149 /* Right shift 4 bits to adjust the offset operand. */
12150 INSERT_OPERAND (0, OFFSET_C
, *ip
,
12151 imm_expr
.X_add_number
>> 4);
12152 imm_expr
.X_op
= O_absent
;
12157 gas_assert (!mips_opts
.micromips
);
12158 if (!reg_lookup (&s
, RTYPE_NUM
| RTYPE_GP
, ®no
))
12160 if (regno
== AT
&& mips_opts
.at
)
12162 if (mips_opts
.at
== ATREG
)
12163 as_warn (_("used $at without \".set noat\""));
12165 as_warn (_("used $%u with \".set at=$%u\""),
12166 regno
, mips_opts
.at
);
12168 INSERT_OPERAND (0, RZ
, *ip
, regno
);
12172 gas_assert (!mips_opts
.micromips
);
12173 if (!reg_lookup (&s
, RTYPE_FPU
, ®no
))
12175 INSERT_OPERAND (0, FZ
, *ip
, regno
);
12185 /* Check whether there is only a single bracketed expression
12186 left. If so, it must be the base register and the
12187 constant must be zero. */
12188 if (*s
== '(' && strchr (s
+ 1, '(') == 0)
12191 /* If this value won't fit into the offset, then go find
12192 a macro that will generate a 16- or 32-bit offset code
12194 i
= my_getSmallExpression (&imm_expr
, imm_reloc
, s
);
12195 if ((i
== 0 && (imm_expr
.X_op
!= O_constant
12196 || imm_expr
.X_add_number
>= 1 << shift
12197 || imm_expr
.X_add_number
< -1 << shift
))
12200 imm_expr
.X_op
= O_absent
;
12203 INSERT_OPERAND (mips_opts
.micromips
, EVAOFFSET
, *ip
,
12204 imm_expr
.X_add_number
);
12205 imm_expr
.X_op
= O_absent
;
12211 as_bad (_("Internal error: bad %s opcode "
12212 "(unknown extension operand type `+%c'): %s %s"),
12213 mips_opts
.micromips
? "microMIPS" : "MIPS",
12214 *args
, insn
->name
, insn
->args
);
12215 /* Further processing is fruitless. */
12220 case '.': /* 10-bit offset. */
12221 gas_assert (mips_opts
.micromips
);
12222 case '~': /* 12-bit offset. */
12224 int shift
= *args
== '.' ? 9 : 11;
12227 /* Check whether there is only a single bracketed expression
12228 left. If so, it must be the base register and the
12229 constant must be zero. */
12230 if (*s
== '(' && strchr (s
+ 1, '(') == 0)
12233 /* If this value won't fit into the offset, then go find
12234 a macro that will generate a 16- or 32-bit offset code
12236 i
= my_getSmallExpression (&imm_expr
, imm_reloc
, s
);
12237 if ((i
== 0 && (imm_expr
.X_op
!= O_constant
12238 || imm_expr
.X_add_number
>= 1 << shift
12239 || imm_expr
.X_add_number
< -1 << shift
))
12242 imm_expr
.X_op
= O_absent
;
12246 INSERT_OPERAND (1, OFFSET10
, *ip
, imm_expr
.X_add_number
);
12248 INSERT_OPERAND (mips_opts
.micromips
,
12249 OFFSET12
, *ip
, imm_expr
.X_add_number
);
12250 imm_expr
.X_op
= O_absent
;
12255 case '<': /* must be at least one digit */
12257 * According to the manual, if the shift amount is greater
12258 * than 31 or less than 0, then the shift amount should be
12259 * mod 32. In reality the mips assembler issues an error.
12260 * We issue a warning and mask out all but the low 5 bits.
12262 my_getExpression (&imm_expr
, s
);
12263 check_absolute_expr (ip
, &imm_expr
);
12264 if ((unsigned long) imm_expr
.X_add_number
> 31)
12265 as_warn (_("Improper shift amount (%lu)"),
12266 (unsigned long) imm_expr
.X_add_number
);
12267 INSERT_OPERAND (mips_opts
.micromips
,
12268 SHAMT
, *ip
, imm_expr
.X_add_number
);
12269 imm_expr
.X_op
= O_absent
;
12273 case '>': /* shift amount minus 32 */
12274 my_getExpression (&imm_expr
, s
);
12275 check_absolute_expr (ip
, &imm_expr
);
12276 if ((unsigned long) imm_expr
.X_add_number
< 32
12277 || (unsigned long) imm_expr
.X_add_number
> 63)
12279 INSERT_OPERAND (mips_opts
.micromips
,
12280 SHAMT
, *ip
, imm_expr
.X_add_number
- 32);
12281 imm_expr
.X_op
= O_absent
;
12285 case 'k': /* CACHE code. */
12286 case 'h': /* PREFX code. */
12287 case '1': /* SYNC type. */
12288 my_getExpression (&imm_expr
, s
);
12289 check_absolute_expr (ip
, &imm_expr
);
12290 if ((unsigned long) imm_expr
.X_add_number
> 31)
12291 as_warn (_("Invalid value for `%s' (%lu)"),
12293 (unsigned long) imm_expr
.X_add_number
);
12297 if (mips_fix_cn63xxp1
12298 && !mips_opts
.micromips
12299 && strcmp ("pref", insn
->name
) == 0)
12300 switch (imm_expr
.X_add_number
)
12309 case 31: /* These are ok. */
12312 default: /* The rest must be changed to 28. */
12313 imm_expr
.X_add_number
= 28;
12316 INSERT_OPERAND (mips_opts
.micromips
,
12317 CACHE
, *ip
, imm_expr
.X_add_number
);
12320 INSERT_OPERAND (mips_opts
.micromips
,
12321 PREFX
, *ip
, imm_expr
.X_add_number
);
12324 INSERT_OPERAND (mips_opts
.micromips
,
12325 STYPE
, *ip
, imm_expr
.X_add_number
);
12328 imm_expr
.X_op
= O_absent
;
12332 case 'c': /* BREAK code. */
12334 unsigned long mask
= (mips_opts
.micromips
12335 ? MICROMIPSOP_MASK_CODE
12338 my_getExpression (&imm_expr
, s
);
12339 check_absolute_expr (ip
, &imm_expr
);
12340 if ((unsigned long) imm_expr
.X_add_number
> mask
)
12341 as_warn (_("Code for %s not in range 0..%lu (%lu)"),
12343 mask
, (unsigned long) imm_expr
.X_add_number
);
12344 INSERT_OPERAND (mips_opts
.micromips
,
12345 CODE
, *ip
, imm_expr
.X_add_number
);
12346 imm_expr
.X_op
= O_absent
;
12351 case 'q': /* Lower BREAK code. */
12353 unsigned long mask
= (mips_opts
.micromips
12354 ? MICROMIPSOP_MASK_CODE2
12357 my_getExpression (&imm_expr
, s
);
12358 check_absolute_expr (ip
, &imm_expr
);
12359 if ((unsigned long) imm_expr
.X_add_number
> mask
)
12360 as_warn (_("Lower code for %s not in range 0..%lu (%lu)"),
12362 mask
, (unsigned long) imm_expr
.X_add_number
);
12363 INSERT_OPERAND (mips_opts
.micromips
,
12364 CODE2
, *ip
, imm_expr
.X_add_number
);
12365 imm_expr
.X_op
= O_absent
;
12370 case 'B': /* 20- or 10-bit syscall/break/wait code. */
12372 unsigned long mask
= (mips_opts
.micromips
12373 ? MICROMIPSOP_MASK_CODE10
12376 my_getExpression (&imm_expr
, s
);
12377 check_absolute_expr (ip
, &imm_expr
);
12378 if ((unsigned long) imm_expr
.X_add_number
> mask
)
12379 as_warn (_("Code for %s not in range 0..%lu (%lu)"),
12381 mask
, (unsigned long) imm_expr
.X_add_number
);
12382 if (mips_opts
.micromips
)
12383 INSERT_OPERAND (1, CODE10
, *ip
, imm_expr
.X_add_number
);
12385 INSERT_OPERAND (0, CODE20
, *ip
, imm_expr
.X_add_number
);
12386 imm_expr
.X_op
= O_absent
;
12391 case 'C': /* 25- or 23-bit coprocessor code. */
12393 unsigned long mask
= (mips_opts
.micromips
12394 ? MICROMIPSOP_MASK_COPZ
12397 my_getExpression (&imm_expr
, s
);
12398 check_absolute_expr (ip
, &imm_expr
);
12399 if ((unsigned long) imm_expr
.X_add_number
> mask
)
12400 as_warn (_("Coproccesor code > %u bits (%lu)"),
12401 mips_opts
.micromips
? 23U : 25U,
12402 (unsigned long) imm_expr
.X_add_number
);
12403 INSERT_OPERAND (mips_opts
.micromips
,
12404 COPZ
, *ip
, imm_expr
.X_add_number
);
12405 imm_expr
.X_op
= O_absent
;
12410 case 'J': /* 19-bit WAIT code. */
12411 gas_assert (!mips_opts
.micromips
);
12412 my_getExpression (&imm_expr
, s
);
12413 check_absolute_expr (ip
, &imm_expr
);
12414 if ((unsigned long) imm_expr
.X_add_number
> OP_MASK_CODE19
)
12416 as_warn (_("Illegal 19-bit code (%lu)"),
12417 (unsigned long) imm_expr
.X_add_number
);
12418 imm_expr
.X_add_number
&= OP_MASK_CODE19
;
12420 INSERT_OPERAND (0, CODE19
, *ip
, imm_expr
.X_add_number
);
12421 imm_expr
.X_op
= O_absent
;
12425 case 'P': /* Performance register. */
12426 gas_assert (!mips_opts
.micromips
);
12427 my_getExpression (&imm_expr
, s
);
12428 check_absolute_expr (ip
, &imm_expr
);
12429 if (imm_expr
.X_add_number
!= 0 && imm_expr
.X_add_number
!= 1)
12430 as_warn (_("Invalid performance register (%lu)"),
12431 (unsigned long) imm_expr
.X_add_number
);
12432 if (imm_expr
.X_add_number
!= 0 && mips_opts
.arch
== CPU_R5900
12433 && (!strcmp(insn
->name
,"mfps") || !strcmp(insn
->name
,"mtps")))
12434 as_warn (_("Invalid performance register (%lu)"),
12435 (unsigned long) imm_expr
.X_add_number
);
12436 INSERT_OPERAND (0, PERFREG
, *ip
, imm_expr
.X_add_number
);
12437 imm_expr
.X_op
= O_absent
;
12441 case 'G': /* Coprocessor destination register. */
12443 unsigned long opcode
= ip
->insn_opcode
;
12444 unsigned long mask
;
12445 unsigned int types
;
12448 if (mips_opts
.micromips
)
12450 mask
= ~((MICROMIPSOP_MASK_RT
<< MICROMIPSOP_SH_RT
)
12451 | (MICROMIPSOP_MASK_RS
<< MICROMIPSOP_SH_RS
)
12452 | (MICROMIPSOP_MASK_SEL
<< MICROMIPSOP_SH_SEL
));
12456 case 0x000000fc: /* mfc0 */
12457 case 0x000002fc: /* mtc0 */
12458 case 0x580000fc: /* dmfc0 */
12459 case 0x580002fc: /* dmtc0 */
12469 opcode
= (opcode
>> OP_SH_OP
) & OP_MASK_OP
;
12470 cop0
= opcode
== OP_OP_COP0
;
12472 types
= RTYPE_NUM
| (cop0
? RTYPE_CP0
: RTYPE_GP
);
12473 ok
= reg_lookup (&s
, types
, ®no
);
12474 if (mips_opts
.micromips
)
12475 INSERT_OPERAND (1, RS
, *ip
, regno
);
12477 INSERT_OPERAND (0, RD
, *ip
, regno
);
12486 case 'y': /* ALNV.PS source register. */
12487 gas_assert (mips_opts
.micromips
);
12489 case 'x': /* Ignore register name. */
12490 case 'U': /* Destination register (CLO/CLZ). */
12491 case 'g': /* Coprocessor destination register. */
12492 gas_assert (!mips_opts
.micromips
);
12493 case 'b': /* Base register. */
12494 case 'd': /* Destination register. */
12495 case 's': /* Source register. */
12496 case 't': /* Target register. */
12497 case 'r': /* Both target and source. */
12498 case 'v': /* Both dest and source. */
12499 case 'w': /* Both dest and target. */
12500 case 'E': /* Coprocessor target register. */
12501 case 'K': /* RDHWR destination register. */
12502 case 'z': /* Must be zero register. */
12505 if (*args
== 'E' || *args
== 'K')
12506 ok
= reg_lookup (&s
, RTYPE_NUM
, ®no
);
12509 ok
= reg_lookup (&s
, RTYPE_NUM
| RTYPE_GP
, ®no
);
12510 if (regno
== AT
&& mips_opts
.at
)
12512 if (mips_opts
.at
== ATREG
)
12513 as_warn (_("Used $at without \".set noat\""));
12515 as_warn (_("Used $%u with \".set at=$%u\""),
12516 regno
, mips_opts
.at
);
12526 if (c
== 'r' || c
== 'v' || c
== 'w')
12533 /* 'z' only matches $0. */
12534 if (c
== 'z' && regno
!= 0)
12537 if (c
== 's' && !strncmp (ip
->insn_mo
->name
, "jalr", 4))
12539 if (regno
== lastregno
)
12542 = _("Source and destination must be different");
12545 if (regno
== 31 && lastregno
== 0xffffffff)
12548 = _("A destination register must be supplied");
12552 /* Now that we have assembled one operand, we use the args
12553 string to figure out where it goes in the instruction. */
12560 INSERT_OPERAND (mips_opts
.micromips
, RS
, *ip
, regno
);
12564 if (mips_opts
.micromips
)
12565 INSERT_OPERAND (1, RS
, *ip
, regno
);
12567 INSERT_OPERAND (0, RD
, *ip
, regno
);
12572 INSERT_OPERAND (mips_opts
.micromips
, RD
, *ip
, regno
);
12576 gas_assert (!mips_opts
.micromips
);
12577 INSERT_OPERAND (0, RD
, *ip
, regno
);
12578 INSERT_OPERAND (0, RT
, *ip
, regno
);
12584 INSERT_OPERAND (mips_opts
.micromips
, RT
, *ip
, regno
);
12588 gas_assert (mips_opts
.micromips
);
12589 INSERT_OPERAND (1, RS3
, *ip
, regno
);
12593 /* This case exists because on the r3000 trunc
12594 expands into a macro which requires a gp
12595 register. On the r6000 or r4000 it is
12596 assembled into a single instruction which
12597 ignores the register. Thus the insn version
12598 is MIPS_ISA2 and uses 'x', and the macro
12599 version is MIPS_ISA1 and uses 't'. */
12603 /* This case is for the div instruction, which
12604 acts differently if the destination argument
12605 is $0. This only matches $0, and is checked
12606 outside the switch. */
12616 INSERT_OPERAND (mips_opts
.micromips
, RS
, *ip
, lastregno
);
12620 INSERT_OPERAND (mips_opts
.micromips
, RT
, *ip
, lastregno
);
12625 case 'O': /* MDMX alignment immediate constant. */
12626 gas_assert (!mips_opts
.micromips
);
12627 my_getExpression (&imm_expr
, s
);
12628 check_absolute_expr (ip
, &imm_expr
);
12629 if ((unsigned long) imm_expr
.X_add_number
> OP_MASK_ALN
)
12630 as_warn (_("Improper align amount (%ld), using low bits"),
12631 (long) imm_expr
.X_add_number
);
12632 INSERT_OPERAND (0, ALN
, *ip
, imm_expr
.X_add_number
);
12633 imm_expr
.X_op
= O_absent
;
12637 case 'Q': /* MDMX vector, element sel, or const. */
12640 /* MDMX Immediate. */
12641 gas_assert (!mips_opts
.micromips
);
12642 my_getExpression (&imm_expr
, s
);
12643 check_absolute_expr (ip
, &imm_expr
);
12644 if ((unsigned long) imm_expr
.X_add_number
> OP_MASK_FT
)
12645 as_warn (_("Invalid MDMX Immediate (%ld)"),
12646 (long) imm_expr
.X_add_number
);
12647 INSERT_OPERAND (0, FT
, *ip
, imm_expr
.X_add_number
);
12648 if (ip
->insn_opcode
& (OP_MASK_VSEL
<< OP_SH_VSEL
))
12649 ip
->insn_opcode
|= MDMX_FMTSEL_IMM_QH
<< OP_SH_VSEL
;
12651 ip
->insn_opcode
|= MDMX_FMTSEL_IMM_OB
<< OP_SH_VSEL
;
12652 imm_expr
.X_op
= O_absent
;
12656 /* Not MDMX Immediate. Fall through. */
12657 case 'X': /* MDMX destination register. */
12658 case 'Y': /* MDMX source register. */
12659 case 'Z': /* MDMX target register. */
12662 gas_assert (!mips_opts
.micromips
);
12663 case 'D': /* Floating point destination register. */
12664 case 'S': /* Floating point source register. */
12665 case 'T': /* Floating point target register. */
12666 case 'R': /* Floating point source register. */
12670 || ((mips_opts
.ase
& ASE_MDMX
)
12671 && (ip
->insn_mo
->pinfo
& FP_D
)
12672 && (ip
->insn_mo
->pinfo
& (INSN_COPROC_MOVE_DELAY
12673 | INSN_COPROC_MEMORY_DELAY
12674 | INSN_LOAD_COPROC_DELAY
12675 | INSN_LOAD_MEMORY_DELAY
12676 | INSN_STORE_MEMORY
))))
12677 rtype
|= RTYPE_VEC
;
12679 if (reg_lookup (&s
, rtype
, ®no
))
12681 if ((regno
& 1) != 0
12683 && !mips_oddfpreg_ok (ip
->insn_mo
, argnum
))
12684 as_warn (_("Float register should be even, was %d"),
12692 if (c
== 'V' || c
== 'W')
12703 INSERT_OPERAND (mips_opts
.micromips
, FD
, *ip
, regno
);
12709 INSERT_OPERAND (mips_opts
.micromips
, FS
, *ip
, regno
);
12713 /* This is like 'Z', but also needs to fix the MDMX
12714 vector/scalar select bits. Note that the
12715 scalar immediate case is handled above. */
12718 int is_qh
= (ip
->insn_opcode
& (1 << OP_SH_VSEL
));
12719 int max_el
= (is_qh
? 3 : 7);
12721 my_getExpression(&imm_expr
, s
);
12722 check_absolute_expr (ip
, &imm_expr
);
12724 if (imm_expr
.X_add_number
> max_el
)
12725 as_bad (_("Bad element selector %ld"),
12726 (long) imm_expr
.X_add_number
);
12727 imm_expr
.X_add_number
&= max_el
;
12728 ip
->insn_opcode
|= (imm_expr
.X_add_number
12731 imm_expr
.X_op
= O_absent
;
12733 as_warn (_("Expecting ']' found '%s'"), s
);
12739 if (ip
->insn_opcode
& (OP_MASK_VSEL
<< OP_SH_VSEL
))
12740 ip
->insn_opcode
|= (MDMX_FMTSEL_VEC_QH
12743 ip
->insn_opcode
|= (MDMX_FMTSEL_VEC_OB
<<
12746 /* Fall through. */
12750 INSERT_OPERAND (mips_opts
.micromips
, FT
, *ip
, regno
);
12754 INSERT_OPERAND (mips_opts
.micromips
, FR
, *ip
, regno
);
12764 INSERT_OPERAND (mips_opts
.micromips
, FS
, *ip
, lastregno
);
12768 INSERT_OPERAND (mips_opts
.micromips
, FT
, *ip
, lastregno
);
12774 my_getExpression (&imm_expr
, s
);
12775 if (imm_expr
.X_op
!= O_big
12776 && imm_expr
.X_op
!= O_constant
)
12777 insn_error
= _("absolute expression required");
12778 if (HAVE_32BIT_GPRS
)
12779 normalize_constant_expr (&imm_expr
);
12784 my_getExpression (&offset_expr
, s
);
12785 normalize_address_expr (&offset_expr
);
12786 *imm_reloc
= BFD_RELOC_32
;
12799 unsigned char temp
[8];
12801 unsigned int length
;
12806 /* These only appear as the last operand in an
12807 instruction, and every instruction that accepts
12808 them in any variant accepts them in all variants.
12809 This means we don't have to worry about backing out
12810 any changes if the instruction does not match.
12812 The difference between them is the size of the
12813 floating point constant and where it goes. For 'F'
12814 and 'L' the constant is 64 bits; for 'f' and 'l' it
12815 is 32 bits. Where the constant is placed is based
12816 on how the MIPS assembler does things:
12819 f -- immediate value
12822 The .lit4 and .lit8 sections are only used if
12823 permitted by the -G argument.
12825 The code below needs to know whether the target register
12826 is 32 or 64 bits wide. It relies on the fact 'f' and
12827 'F' are used with GPR-based instructions and 'l' and
12828 'L' are used with FPR-based instructions. */
12830 f64
= *args
== 'F' || *args
== 'L';
12831 using_gprs
= *args
== 'F' || *args
== 'f';
12833 save_in
= input_line_pointer
;
12834 input_line_pointer
= s
;
12835 err
= md_atof (f64
? 'd' : 'f', (char *) temp
, &len
);
12837 s
= input_line_pointer
;
12838 input_line_pointer
= save_in
;
12839 if (err
!= NULL
&& *err
!= '\0')
12841 as_bad (_("Bad floating point constant: %s"), err
);
12842 memset (temp
, '\0', sizeof temp
);
12843 length
= f64
? 8 : 4;
12846 gas_assert (length
== (unsigned) (f64
? 8 : 4));
12850 && (g_switch_value
< 4
12851 || (temp
[0] == 0 && temp
[1] == 0)
12852 || (temp
[2] == 0 && temp
[3] == 0))))
12854 imm_expr
.X_op
= O_constant
;
12855 if (!target_big_endian
)
12856 imm_expr
.X_add_number
= bfd_getl32 (temp
);
12858 imm_expr
.X_add_number
= bfd_getb32 (temp
);
12860 else if (length
> 4
12861 && !mips_disable_float_construction
12862 /* Constants can only be constructed in GPRs and
12863 copied to FPRs if the GPRs are at least as wide
12864 as the FPRs. Force the constant into memory if
12865 we are using 64-bit FPRs but the GPRs are only
12868 || !(HAVE_64BIT_FPRS
&& HAVE_32BIT_GPRS
))
12869 && ((temp
[0] == 0 && temp
[1] == 0)
12870 || (temp
[2] == 0 && temp
[3] == 0))
12871 && ((temp
[4] == 0 && temp
[5] == 0)
12872 || (temp
[6] == 0 && temp
[7] == 0)))
12874 /* The value is simple enough to load with a couple of
12875 instructions. If using 32-bit registers, set
12876 imm_expr to the high order 32 bits and offset_expr to
12877 the low order 32 bits. Otherwise, set imm_expr to
12878 the entire 64 bit constant. */
12879 if (using_gprs
? HAVE_32BIT_GPRS
: HAVE_32BIT_FPRS
)
12881 imm_expr
.X_op
= O_constant
;
12882 offset_expr
.X_op
= O_constant
;
12883 if (!target_big_endian
)
12885 imm_expr
.X_add_number
= bfd_getl32 (temp
+ 4);
12886 offset_expr
.X_add_number
= bfd_getl32 (temp
);
12890 imm_expr
.X_add_number
= bfd_getb32 (temp
);
12891 offset_expr
.X_add_number
= bfd_getb32 (temp
+ 4);
12893 if (offset_expr
.X_add_number
== 0)
12894 offset_expr
.X_op
= O_absent
;
12898 imm_expr
.X_op
= O_constant
;
12899 if (!target_big_endian
)
12900 imm_expr
.X_add_number
= bfd_getl64 (temp
);
12902 imm_expr
.X_add_number
= bfd_getb64 (temp
);
12907 const char *newname
;
12910 /* Switch to the right section. */
12912 subseg
= now_subseg
;
12915 default: /* unused default case avoids warnings. */
12917 newname
= RDATA_SECTION_NAME
;
12918 if (g_switch_value
>= 8)
12922 newname
= RDATA_SECTION_NAME
;
12925 gas_assert (g_switch_value
>= 4);
12929 new_seg
= subseg_new (newname
, (subsegT
) 0);
12930 bfd_set_section_flags (stdoutput
, new_seg
,
12935 frag_align (*args
== 'l' ? 2 : 3, 0, 0);
12936 if (strncmp (TARGET_OS
, "elf", 3) != 0)
12937 record_alignment (new_seg
, 4);
12939 record_alignment (new_seg
, *args
== 'l' ? 2 : 3);
12940 if (seg
== now_seg
)
12941 as_bad (_("Can't use floating point insn in this section"));
12943 /* Set the argument to the current address in the
12945 offset_expr
.X_op
= O_symbol
;
12946 offset_expr
.X_add_symbol
= symbol_temp_new_now ();
12947 offset_expr
.X_add_number
= 0;
12949 /* Put the floating point number into the section. */
12950 p
= frag_more ((int) length
);
12951 memcpy (p
, temp
, length
);
12953 /* Switch back to the original section. */
12954 subseg_set (seg
, subseg
);
12959 case 'i': /* 16-bit unsigned immediate. */
12960 case 'j': /* 16-bit signed immediate. */
12961 *imm_reloc
= BFD_RELOC_LO16
;
12962 if (my_getSmallExpression (&imm_expr
, imm_reloc
, s
) == 0)
12965 offsetT minval
, maxval
;
12967 more
= (insn
+ 1 < past
12968 && strcmp (insn
->name
, insn
[1].name
) == 0);
12970 /* For compatibility with older assemblers, we accept
12971 0x8000-0xffff as signed 16-bit numbers when only
12972 signed numbers are allowed. */
12974 minval
= 0, maxval
= 0xffff;
12976 minval
= -0x8000, maxval
= 0x7fff;
12978 minval
= -0x8000, maxval
= 0xffff;
12980 if (imm_expr
.X_op
!= O_constant
12981 || imm_expr
.X_add_number
< minval
12982 || imm_expr
.X_add_number
> maxval
)
12986 if (imm_expr
.X_op
== O_constant
12987 || imm_expr
.X_op
== O_big
)
12988 as_bad (_("Expression out of range"));
12994 case 'o': /* 16-bit offset. */
12995 offset_reloc
[0] = BFD_RELOC_LO16
;
12996 offset_reloc
[1] = BFD_RELOC_UNUSED
;
12997 offset_reloc
[2] = BFD_RELOC_UNUSED
;
12999 /* Check whether there is only a single bracketed expression
13000 left. If so, it must be the base register and the
13001 constant must be zero. */
13002 if (*s
== '(' && strchr (s
+ 1, '(') == 0)
13004 offset_expr
.X_op
= O_constant
;
13005 offset_expr
.X_add_number
= 0;
13009 /* If this value won't fit into a 16 bit offset, then go
13010 find a macro that will generate the 32 bit offset
13012 if (my_getSmallExpression (&offset_expr
, offset_reloc
, s
) == 0
13013 && (offset_expr
.X_op
!= O_constant
13014 || offset_expr
.X_add_number
>= 0x8000
13015 || offset_expr
.X_add_number
< -0x8000))
13021 case 'p': /* PC-relative offset. */
13022 *offset_reloc
= BFD_RELOC_16_PCREL_S2
;
13023 my_getExpression (&offset_expr
, s
);
13027 case 'u': /* Upper 16 bits. */
13028 *imm_reloc
= BFD_RELOC_LO16
;
13029 if (my_getSmallExpression (&imm_expr
, imm_reloc
, s
) == 0
13030 && imm_expr
.X_op
== O_constant
13031 && (imm_expr
.X_add_number
< 0
13032 || imm_expr
.X_add_number
>= 0x10000))
13033 as_bad (_("lui expression (%lu) not in range 0..65535"),
13034 (unsigned long) imm_expr
.X_add_number
);
13038 case 'a': /* 26-bit address. */
13040 *offset_reloc
= BFD_RELOC_MIPS_JMP
;
13041 my_getExpression (&offset_expr
, s
);
13045 case 'N': /* 3-bit branch condition code. */
13046 case 'M': /* 3-bit compare condition code. */
13048 if (ip
->insn_mo
->pinfo
& (FP_D
| FP_S
))
13049 rtype
|= RTYPE_FCC
;
13050 if (!reg_lookup (&s
, rtype
, ®no
))
13052 if ((strcmp (str
+ strlen (str
) - 3, ".ps") == 0
13053 || strcmp (str
+ strlen (str
) - 5, "any2f") == 0
13054 || strcmp (str
+ strlen (str
) - 5, "any2t") == 0)
13055 && (regno
& 1) != 0)
13056 as_warn (_("Condition code register should be even for %s, "
13059 if ((strcmp (str
+ strlen (str
) - 5, "any4f") == 0
13060 || strcmp (str
+ strlen (str
) - 5, "any4t") == 0)
13061 && (regno
& 3) != 0)
13062 as_warn (_("Condition code register should be 0 or 4 for %s, "
13066 INSERT_OPERAND (mips_opts
.micromips
, BCC
, *ip
, regno
);
13068 INSERT_OPERAND (mips_opts
.micromips
, CCC
, *ip
, regno
);
13072 if (s
[0] == '0' && (s
[1] == 'x' || s
[1] == 'X'))
13083 while (ISDIGIT (*s
));
13086 c
= 8; /* Invalid sel value. */
13089 as_bad (_("Invalid coprocessor sub-selection value (0-7)"));
13090 INSERT_OPERAND (mips_opts
.micromips
, SEL
, *ip
, c
);
13094 gas_assert (!mips_opts
.micromips
);
13095 /* Must be at least one digit. */
13096 my_getExpression (&imm_expr
, s
);
13097 check_absolute_expr (ip
, &imm_expr
);
13099 if ((unsigned long) imm_expr
.X_add_number
13100 > (unsigned long) OP_MASK_VECBYTE
)
13102 as_bad (_("bad byte vector index (%ld)"),
13103 (long) imm_expr
.X_add_number
);
13104 imm_expr
.X_add_number
= 0;
13107 INSERT_OPERAND (0, VECBYTE
, *ip
, imm_expr
.X_add_number
);
13108 imm_expr
.X_op
= O_absent
;
13113 gas_assert (!mips_opts
.micromips
);
13114 my_getExpression (&imm_expr
, s
);
13115 check_absolute_expr (ip
, &imm_expr
);
13117 if ((unsigned long) imm_expr
.X_add_number
13118 > (unsigned long) OP_MASK_VECALIGN
)
13120 as_bad (_("bad byte vector index (%ld)"),
13121 (long) imm_expr
.X_add_number
);
13122 imm_expr
.X_add_number
= 0;
13125 INSERT_OPERAND (0, VECALIGN
, *ip
, imm_expr
.X_add_number
);
13126 imm_expr
.X_op
= O_absent
;
13130 case 'm': /* Opcode extension character. */
13131 gas_assert (mips_opts
.micromips
);
13136 if (strncmp (s
, "$pc", 3) == 0)
13163 ok
= reg_lookup (&s
, RTYPE_NUM
| RTYPE_GP
, ®no
);
13164 if (regno
== AT
&& mips_opts
.at
)
13166 if (mips_opts
.at
== ATREG
)
13167 as_warn (_("Used $at without \".set noat\""));
13169 as_warn (_("Used $%u with \".set at=$%u\""),
13170 regno
, mips_opts
.at
);
13176 gas_assert (args
[1] == ',');
13182 gas_assert (args
[1] == ',');
13184 continue; /* Nothing to do. */
13190 if (c
== 'j' && !strncmp (ip
->insn_mo
->name
, "jalr", 4))
13192 if (regno
== lastregno
)
13195 = _("Source and destination must be different");
13198 if (regno
== 31 && lastregno
== 0xffffffff)
13201 = _("A destination register must be supplied");
13212 gas_assert (args
[1] == ',');
13219 gas_assert (args
[1] == ',');
13222 continue; /* Nothing to do. */
13226 /* Make sure regno is the same as lastregno. */
13227 if (c
== 't' && regno
!= lastregno
)
13230 /* Make sure regno is the same as destregno. */
13231 if (c
== 'x' && regno
!= destregno
)
13234 /* We need to save regno, before regno maps to the
13235 microMIPS register encoding. */
13245 regno
= ILLEGAL_REG
;
13249 regno
= mips32_to_micromips_reg_b_map
[regno
];
13253 regno
= mips32_to_micromips_reg_c_map
[regno
];
13257 regno
= mips32_to_micromips_reg_d_map
[regno
];
13261 regno
= mips32_to_micromips_reg_e_map
[regno
];
13265 regno
= mips32_to_micromips_reg_f_map
[regno
];
13269 regno
= mips32_to_micromips_reg_g_map
[regno
];
13273 s
+= strspn (s
, " \t");
13276 regno
= ILLEGAL_REG
;
13280 s
+= strspn (s
, " \t");
13281 ok
= reg_lookup (&s
, RTYPE_NUM
| RTYPE_GP
, ®no2
);
13284 regno
= ILLEGAL_REG
;
13287 if (regno2
== AT
&& mips_opts
.at
)
13289 if (mips_opts
.at
== ATREG
)
13290 as_warn (_("Used $at without \".set noat\""));
13292 as_warn (_("Used $%u with \".set at=$%u\""),
13293 regno2
, mips_opts
.at
);
13295 regno
= (mips_lookup_reg_pair
13297 micromips_to_32_reg_h_map1
,
13298 micromips_to_32_reg_h_map2
, 8));
13302 regno
= mips32_to_micromips_reg_l_map
[regno
];
13306 regno
= mips32_to_micromips_reg_m_map
[regno
];
13310 regno
= mips32_to_micromips_reg_n_map
[regno
];
13314 regno
= mips32_to_micromips_reg_q_map
[regno
];
13319 regno
= ILLEGAL_REG
;
13324 regno
= ILLEGAL_REG
;
13329 regno
= ILLEGAL_REG
;
13332 case 'j': /* Do nothing. */
13342 if (regno
== ILLEGAL_REG
)
13348 INSERT_OPERAND (1, MB
, *ip
, regno
);
13352 INSERT_OPERAND (1, MC
, *ip
, regno
);
13356 INSERT_OPERAND (1, MD
, *ip
, regno
);
13360 INSERT_OPERAND (1, ME
, *ip
, regno
);
13364 INSERT_OPERAND (1, MF
, *ip
, regno
);
13368 INSERT_OPERAND (1, MG
, *ip
, regno
);
13372 INSERT_OPERAND (1, MH
, *ip
, regno
);
13376 INSERT_OPERAND (1, MJ
, *ip
, regno
);
13380 INSERT_OPERAND (1, ML
, *ip
, regno
);
13384 INSERT_OPERAND (1, MM
, *ip
, regno
);
13388 INSERT_OPERAND (1, MN
, *ip
, regno
);
13392 INSERT_OPERAND (1, MP
, *ip
, regno
);
13396 INSERT_OPERAND (1, MQ
, *ip
, regno
);
13399 case 'a': /* Do nothing. */
13400 case 's': /* Do nothing. */
13401 case 't': /* Do nothing. */
13402 case 'x': /* Do nothing. */
13403 case 'y': /* Do nothing. */
13404 case 'z': /* Do nothing. */
13414 bfd_reloc_code_real_type r
[3];
13418 /* Check whether there is only a single bracketed
13419 expression left. If so, it must be the base register
13420 and the constant must be zero. */
13421 if (*s
== '(' && strchr (s
+ 1, '(') == 0)
13423 INSERT_OPERAND (1, IMMA
, *ip
, 0);
13427 if (my_getSmallExpression (&ep
, r
, s
) > 0
13428 || !expr_const_in_range (&ep
, -64, 64, 2))
13431 imm
= ep
.X_add_number
>> 2;
13432 INSERT_OPERAND (1, IMMA
, *ip
, imm
);
13439 bfd_reloc_code_real_type r
[3];
13443 if (my_getSmallExpression (&ep
, r
, s
) > 0
13444 || ep
.X_op
!= O_constant
)
13447 for (imm
= 0; imm
< 8; imm
++)
13448 if (micromips_imm_b_map
[imm
] == ep
.X_add_number
)
13453 INSERT_OPERAND (1, IMMB
, *ip
, imm
);
13460 bfd_reloc_code_real_type r
[3];
13464 if (my_getSmallExpression (&ep
, r
, s
) > 0
13465 || ep
.X_op
!= O_constant
)
13468 for (imm
= 0; imm
< 16; imm
++)
13469 if (micromips_imm_c_map
[imm
] == ep
.X_add_number
)
13474 INSERT_OPERAND (1, IMMC
, *ip
, imm
);
13479 case 'D': /* pc relative offset */
13480 case 'E': /* pc relative offset */
13481 my_getExpression (&offset_expr
, s
);
13482 if (offset_expr
.X_op
== O_register
)
13485 if (!forced_insn_length
)
13486 *offset_reloc
= (int) BFD_RELOC_UNUSED
+ c
;
13488 *offset_reloc
= BFD_RELOC_MICROMIPS_10_PCREL_S1
;
13490 *offset_reloc
= BFD_RELOC_MICROMIPS_7_PCREL_S1
;
13496 bfd_reloc_code_real_type r
[3];
13500 if (my_getSmallExpression (&ep
, r
, s
) > 0
13501 || !expr_const_in_range (&ep
, 0, 16, 0))
13504 imm
= ep
.X_add_number
;
13505 INSERT_OPERAND (1, IMMF
, *ip
, imm
);
13512 bfd_reloc_code_real_type r
[3];
13516 /* Check whether there is only a single bracketed
13517 expression left. If so, it must be the base register
13518 and the constant must be zero. */
13519 if (*s
== '(' && strchr (s
+ 1, '(') == 0)
13521 INSERT_OPERAND (1, IMMG
, *ip
, 0);
13525 if (my_getSmallExpression (&ep
, r
, s
) > 0
13526 || !expr_const_in_range (&ep
, -1, 15, 0))
13529 imm
= ep
.X_add_number
& 15;
13530 INSERT_OPERAND (1, IMMG
, *ip
, imm
);
13537 bfd_reloc_code_real_type r
[3];
13541 /* Check whether there is only a single bracketed
13542 expression left. If so, it must be the base register
13543 and the constant must be zero. */
13544 if (*s
== '(' && strchr (s
+ 1, '(') == 0)
13546 INSERT_OPERAND (1, IMMH
, *ip
, 0);
13550 if (my_getSmallExpression (&ep
, r
, s
) > 0
13551 || !expr_const_in_range (&ep
, 0, 16, 1))
13554 imm
= ep
.X_add_number
>> 1;
13555 INSERT_OPERAND (1, IMMH
, *ip
, imm
);
13562 bfd_reloc_code_real_type r
[3];
13566 if (my_getSmallExpression (&ep
, r
, s
) > 0
13567 || !expr_const_in_range (&ep
, -1, 127, 0))
13570 imm
= ep
.X_add_number
& 127;
13571 INSERT_OPERAND (1, IMMI
, *ip
, imm
);
13578 bfd_reloc_code_real_type r
[3];
13582 /* Check whether there is only a single bracketed
13583 expression left. If so, it must be the base register
13584 and the constant must be zero. */
13585 if (*s
== '(' && strchr (s
+ 1, '(') == 0)
13587 INSERT_OPERAND (1, IMMJ
, *ip
, 0);
13591 if (my_getSmallExpression (&ep
, r
, s
) > 0
13592 || !expr_const_in_range (&ep
, 0, 16, 2))
13595 imm
= ep
.X_add_number
>> 2;
13596 INSERT_OPERAND (1, IMMJ
, *ip
, imm
);
13603 bfd_reloc_code_real_type r
[3];
13607 /* Check whether there is only a single bracketed
13608 expression left. If so, it must be the base register
13609 and the constant must be zero. */
13610 if (*s
== '(' && strchr (s
+ 1, '(') == 0)
13612 INSERT_OPERAND (1, IMML
, *ip
, 0);
13616 if (my_getSmallExpression (&ep
, r
, s
) > 0
13617 || !expr_const_in_range (&ep
, 0, 16, 0))
13620 imm
= ep
.X_add_number
;
13621 INSERT_OPERAND (1, IMML
, *ip
, imm
);
13628 bfd_reloc_code_real_type r
[3];
13632 if (my_getSmallExpression (&ep
, r
, s
) > 0
13633 || !expr_const_in_range (&ep
, 1, 9, 0))
13636 imm
= ep
.X_add_number
& 7;
13637 INSERT_OPERAND (1, IMMM
, *ip
, imm
);
13642 case 'N': /* Register list for lwm and swm. */
13644 /* A comma-separated list of registers and/or
13645 dash-separated contiguous ranges including
13646 both ra and a set of one or more registers
13647 starting at s0 up to s3 which have to be
13654 and any permutations of these. */
13655 unsigned int reglist
;
13658 if (!reglist_lookup (&s
, RTYPE_NUM
| RTYPE_GP
, ®list
))
13661 if ((reglist
& 0xfff1ffff) != 0x80010000)
13664 reglist
= (reglist
>> 17) & 7;
13666 if ((reglist
& -reglist
) != reglist
)
13669 imm
= ffs (reglist
) - 1;
13670 INSERT_OPERAND (1, IMMN
, *ip
, imm
);
13674 case 'O': /* sdbbp 4-bit code. */
13676 bfd_reloc_code_real_type r
[3];
13680 if (my_getSmallExpression (&ep
, r
, s
) > 0
13681 || !expr_const_in_range (&ep
, 0, 16, 0))
13684 imm
= ep
.X_add_number
;
13685 INSERT_OPERAND (1, IMMO
, *ip
, imm
);
13692 bfd_reloc_code_real_type r
[3];
13696 if (my_getSmallExpression (&ep
, r
, s
) > 0
13697 || !expr_const_in_range (&ep
, 0, 32, 2))
13700 imm
= ep
.X_add_number
>> 2;
13701 INSERT_OPERAND (1, IMMP
, *ip
, imm
);
13708 bfd_reloc_code_real_type r
[3];
13712 if (my_getSmallExpression (&ep
, r
, s
) > 0
13713 || !expr_const_in_range (&ep
, -0x400000, 0x400000, 2))
13716 imm
= ep
.X_add_number
>> 2;
13717 INSERT_OPERAND (1, IMMQ
, *ip
, imm
);
13724 bfd_reloc_code_real_type r
[3];
13728 /* Check whether there is only a single bracketed
13729 expression left. If so, it must be the base register
13730 and the constant must be zero. */
13731 if (*s
== '(' && strchr (s
+ 1, '(') == 0)
13733 INSERT_OPERAND (1, IMMU
, *ip
, 0);
13737 if (my_getSmallExpression (&ep
, r
, s
) > 0
13738 || !expr_const_in_range (&ep
, 0, 32, 2))
13741 imm
= ep
.X_add_number
>> 2;
13742 INSERT_OPERAND (1, IMMU
, *ip
, imm
);
13749 bfd_reloc_code_real_type r
[3];
13753 if (my_getSmallExpression (&ep
, r
, s
) > 0
13754 || !expr_const_in_range (&ep
, 0, 64, 2))
13757 imm
= ep
.X_add_number
>> 2;
13758 INSERT_OPERAND (1, IMMW
, *ip
, imm
);
13765 bfd_reloc_code_real_type r
[3];
13769 if (my_getSmallExpression (&ep
, r
, s
) > 0
13770 || !expr_const_in_range (&ep
, -8, 8, 0))
13773 imm
= ep
.X_add_number
;
13774 INSERT_OPERAND (1, IMMX
, *ip
, imm
);
13781 bfd_reloc_code_real_type r
[3];
13785 if (my_getSmallExpression (&ep
, r
, s
) > 0
13786 || expr_const_in_range (&ep
, -2, 2, 2)
13787 || !expr_const_in_range (&ep
, -258, 258, 2))
13790 imm
= ep
.X_add_number
>> 2;
13791 imm
= ((imm
>> 1) & ~0xff) | (imm
& 0xff);
13792 INSERT_OPERAND (1, IMMY
, *ip
, imm
);
13799 bfd_reloc_code_real_type r
[3];
13802 if (my_getSmallExpression (&ep
, r
, s
) > 0
13803 || !expr_const_in_range (&ep
, 0, 1, 0))
13810 as_bad (_("Internal error: bad microMIPS opcode "
13811 "(unknown extension operand type `m%c'): %s %s"),
13812 *args
, insn
->name
, insn
->args
);
13813 /* Further processing is fruitless. */
13818 case 'n': /* Register list for 32-bit lwm and swm. */
13819 gas_assert (mips_opts
.micromips
);
13821 /* A comma-separated list of registers and/or
13822 dash-separated contiguous ranges including
13823 at least one of ra and a set of one or more
13824 registers starting at s0 up to s7 and then
13825 s8 which have to be consecutive, e.g.:
13833 and any permutations of these. */
13834 unsigned int reglist
;
13838 if (!reglist_lookup (&s
, RTYPE_NUM
| RTYPE_GP
, ®list
))
13841 if ((reglist
& 0x3f00ffff) != 0)
13844 ra
= (reglist
>> 27) & 0x10;
13845 reglist
= ((reglist
>> 22) & 0x100) | ((reglist
>> 16) & 0xff);
13847 if ((reglist
& -reglist
) != reglist
)
13850 imm
= (ffs (reglist
) - 1) | ra
;
13851 INSERT_OPERAND (1, RT
, *ip
, imm
);
13852 imm_expr
.X_op
= O_absent
;
13856 case '|': /* 4-bit trap code. */
13857 gas_assert (mips_opts
.micromips
);
13858 my_getExpression (&imm_expr
, s
);
13859 check_absolute_expr (ip
, &imm_expr
);
13860 if ((unsigned long) imm_expr
.X_add_number
13861 > MICROMIPSOP_MASK_TRAP
)
13862 as_bad (_("Trap code (%lu) for %s not in 0..15 range"),
13863 (unsigned long) imm_expr
.X_add_number
,
13864 ip
->insn_mo
->name
);
13865 INSERT_OPERAND (1, TRAP
, *ip
, imm_expr
.X_add_number
);
13866 imm_expr
.X_op
= O_absent
;
13871 as_bad (_("Bad char = '%c'\n"), *args
);
13876 /* Args don't match. */
13878 insn_error
= _("Illegal operands");
13879 if (insn
+ 1 < past
&& !strcmp (insn
->name
, insn
[1].name
))
13884 else if (wrong_delay_slot_insns
&& need_delay_slot_ok
)
13886 gas_assert (firstinsn
);
13887 need_delay_slot_ok
= FALSE
;
13896 #define SKIP_SPACE_TABS(S) { while (*(S) == ' ' || *(S) == '\t') ++(S); }
13898 /* This routine assembles an instruction into its binary format when
13899 assembling for the mips16. As a side effect, it sets one of the
13900 global variables imm_reloc or offset_reloc to the type of relocation
13901 to do if one of the operands is an address expression. It also sets
13902 forced_insn_length to the resulting instruction size in bytes if the
13903 user explicitly requested a small or extended instruction. */
13906 mips16_ip (char *str
, struct mips_cl_insn
*ip
)
13910 struct mips_opcode
*insn
;
13912 unsigned int regno
;
13913 unsigned int lastregno
= 0;
13919 forced_insn_length
= 0;
13921 for (s
= str
; ISLOWER (*s
); ++s
)
13933 if (s
[1] == 't' && s
[2] == ' ')
13936 forced_insn_length
= 2;
13940 else if (s
[1] == 'e' && s
[2] == ' ')
13943 forced_insn_length
= 4;
13947 /* Fall through. */
13949 insn_error
= _("unknown opcode");
13953 if (mips_opts
.noautoextend
&& !forced_insn_length
)
13954 forced_insn_length
= 2;
13956 if ((insn
= (struct mips_opcode
*) hash_find (mips16_op_hash
, str
)) == NULL
)
13958 insn_error
= _("unrecognized opcode");
13967 gas_assert (strcmp (insn
->name
, str
) == 0);
13969 ok
= is_opcode_valid_16 (insn
);
13972 if (insn
+ 1 < &mips16_opcodes
[bfd_mips16_num_opcodes
]
13973 && strcmp (insn
->name
, insn
[1].name
) == 0)
13982 static char buf
[100];
13984 _("Opcode not supported on this processor: %s (%s)"),
13985 mips_cpu_info_from_arch (mips_opts
.arch
)->name
,
13986 mips_cpu_info_from_isa (mips_opts
.isa
)->name
);
13993 create_insn (ip
, insn
);
13994 imm_expr
.X_op
= O_absent
;
13995 imm_reloc
[0] = BFD_RELOC_UNUSED
;
13996 imm_reloc
[1] = BFD_RELOC_UNUSED
;
13997 imm_reloc
[2] = BFD_RELOC_UNUSED
;
13998 imm2_expr
.X_op
= O_absent
;
13999 offset_expr
.X_op
= O_absent
;
14000 offset_reloc
[0] = BFD_RELOC_UNUSED
;
14001 offset_reloc
[1] = BFD_RELOC_UNUSED
;
14002 offset_reloc
[2] = BFD_RELOC_UNUSED
;
14003 for (args
= insn
->args
; 1; ++args
)
14010 /* In this switch statement we call break if we did not find
14011 a match, continue if we did find a match, or return if we
14022 /* Stuff the immediate value in now, if we can. */
14023 if (imm_expr
.X_op
== O_constant
14024 && *imm_reloc
> BFD_RELOC_UNUSED
14025 && insn
->pinfo
!= INSN_MACRO
14026 && calculate_reloc (*offset_reloc
,
14027 imm_expr
.X_add_number
, &value
))
14029 mips16_immed (NULL
, 0, *imm_reloc
- BFD_RELOC_UNUSED
,
14030 *offset_reloc
, value
, forced_insn_length
,
14032 imm_expr
.X_op
= O_absent
;
14033 *imm_reloc
= BFD_RELOC_UNUSED
;
14034 *offset_reloc
= BFD_RELOC_UNUSED
;
14048 MIPS16_INSERT_OPERAND (RX
, *ip
, lastregno
);
14051 MIPS16_INSERT_OPERAND (RY
, *ip
, lastregno
);
14067 MIPS16_INSERT_OPERAND (RX
, *ip
, lastregno
);
14069 MIPS16_INSERT_OPERAND (RY
, *ip
, lastregno
);
14073 /* Fall through. */
14084 if (!reg_lookup (&s
, RTYPE_NUM
| RTYPE_GP
, ®no
))
14086 if (c
== 'v' || c
== 'w')
14089 MIPS16_INSERT_OPERAND (RX
, *ip
, lastregno
);
14091 MIPS16_INSERT_OPERAND (RY
, *ip
, lastregno
);
14102 if (c
== 'v' || c
== 'w')
14104 regno
= mips16_to_32_reg_map
[lastregno
];
14118 regno
= mips32_to_16_reg_map
[regno
];
14123 regno
= ILLEGAL_REG
;
14128 regno
= ILLEGAL_REG
;
14133 regno
= ILLEGAL_REG
;
14138 if (regno
== AT
&& mips_opts
.at
)
14140 if (mips_opts
.at
== ATREG
)
14141 as_warn (_("used $at without \".set noat\""));
14143 as_warn (_("used $%u with \".set at=$%u\""),
14144 regno
, mips_opts
.at
);
14152 if (regno
== ILLEGAL_REG
)
14159 MIPS16_INSERT_OPERAND (RX
, *ip
, regno
);
14163 MIPS16_INSERT_OPERAND (RY
, *ip
, regno
);
14166 MIPS16_INSERT_OPERAND (RZ
, *ip
, regno
);
14169 MIPS16_INSERT_OPERAND (MOVE32Z
, *ip
, regno
);
14175 MIPS16_INSERT_OPERAND (REGR32
, *ip
, regno
);
14178 regno
= ((regno
& 7) << 2) | ((regno
& 0x18) >> 3);
14179 MIPS16_INSERT_OPERAND (REG32R
, *ip
, regno
);
14189 if (strncmp (s
, "$pc", 3) == 0)
14206 i
= my_getSmallExpression (&imm_expr
, imm_reloc
, s
);
14209 if (imm_expr
.X_op
!= O_constant
)
14211 forced_insn_length
= 4;
14212 ip
->insn_opcode
|= MIPS16_EXTEND
;
14216 /* We need to relax this instruction. */
14217 *offset_reloc
= *imm_reloc
;
14218 *imm_reloc
= (int) BFD_RELOC_UNUSED
+ c
;
14223 *imm_reloc
= BFD_RELOC_UNUSED
;
14224 /* Fall through. */
14231 my_getExpression (&imm_expr
, s
);
14232 if (imm_expr
.X_op
== O_register
)
14234 /* What we thought was an expression turned out to
14237 if (s
[0] == '(' && args
[1] == '(')
14239 /* It looks like the expression was omitted
14240 before a register indirection, which means
14241 that the expression is implicitly zero. We
14242 still set up imm_expr, so that we handle
14243 explicit extensions correctly. */
14244 imm_expr
.X_op
= O_constant
;
14245 imm_expr
.X_add_number
= 0;
14246 *imm_reloc
= (int) BFD_RELOC_UNUSED
+ c
;
14253 /* We need to relax this instruction. */
14254 *imm_reloc
= (int) BFD_RELOC_UNUSED
+ c
;
14263 /* We use offset_reloc rather than imm_reloc for the PC
14264 relative operands. This lets macros with both
14265 immediate and address operands work correctly. */
14266 my_getExpression (&offset_expr
, s
);
14268 if (offset_expr
.X_op
== O_register
)
14271 /* We need to relax this instruction. */
14272 *offset_reloc
= (int) BFD_RELOC_UNUSED
+ c
;
14276 case '6': /* break code */
14277 my_getExpression (&imm_expr
, s
);
14278 check_absolute_expr (ip
, &imm_expr
);
14279 if ((unsigned long) imm_expr
.X_add_number
> 63)
14280 as_warn (_("Invalid value for `%s' (%lu)"),
14282 (unsigned long) imm_expr
.X_add_number
);
14283 MIPS16_INSERT_OPERAND (IMM6
, *ip
, imm_expr
.X_add_number
);
14284 imm_expr
.X_op
= O_absent
;
14288 case 'a': /* 26 bit address */
14290 my_getExpression (&offset_expr
, s
);
14292 *offset_reloc
= BFD_RELOC_MIPS16_JMP
;
14293 ip
->insn_opcode
<<= 16;
14296 case 'l': /* register list for entry macro */
14297 case 'L': /* register list for exit macro */
14307 unsigned int freg
, reg1
, reg2
;
14309 while (*s
== ' ' || *s
== ',')
14311 if (reg_lookup (&s
, RTYPE_GP
| RTYPE_NUM
, ®1
))
14313 else if (reg_lookup (&s
, RTYPE_FPU
, ®1
))
14317 as_bad (_("can't parse register list"));
14327 if (!reg_lookup (&s
, freg
? RTYPE_FPU
14328 : (RTYPE_GP
| RTYPE_NUM
), ®2
))
14330 as_bad (_("invalid register list"));
14334 if (freg
&& reg1
== 0 && reg2
== 0 && c
== 'L')
14336 mask
&= ~ (7 << 3);
14339 else if (freg
&& reg1
== 0 && reg2
== 1 && c
== 'L')
14341 mask
&= ~ (7 << 3);
14344 else if (reg1
== 4 && reg2
>= 4 && reg2
<= 7 && c
!= 'L')
14345 mask
|= (reg2
- 3) << 3;
14346 else if (reg1
== 16 && reg2
>= 16 && reg2
<= 17)
14347 mask
|= (reg2
- 15) << 1;
14348 else if (reg1
== RA
&& reg2
== RA
)
14352 as_bad (_("invalid register list"));
14356 /* The mask is filled in in the opcode table for the
14357 benefit of the disassembler. We remove it before
14358 applying the actual mask. */
14359 ip
->insn_opcode
&= ~ ((7 << 3) << MIPS16OP_SH_IMM6
);
14360 ip
->insn_opcode
|= mask
<< MIPS16OP_SH_IMM6
;
14364 case 'm': /* Register list for save insn. */
14365 case 'M': /* Register list for restore insn. */
14367 int opcode
= ip
->insn_opcode
;
14368 int framesz
= 0, seen_framesz
= 0;
14369 int nargs
= 0, statics
= 0, sregs
= 0;
14373 unsigned int reg1
, reg2
;
14375 SKIP_SPACE_TABS (s
);
14378 SKIP_SPACE_TABS (s
);
14380 my_getExpression (&imm_expr
, s
);
14381 if (imm_expr
.X_op
== O_constant
)
14383 /* Handle the frame size. */
14386 as_bad (_("more than one frame size in list"));
14390 framesz
= imm_expr
.X_add_number
;
14391 imm_expr
.X_op
= O_absent
;
14396 if (! reg_lookup (&s
, RTYPE_GP
| RTYPE_NUM
, ®1
))
14398 as_bad (_("can't parse register list"));
14410 if (! reg_lookup (&s
, RTYPE_GP
| RTYPE_NUM
, ®2
)
14413 as_bad (_("can't parse register list"));
14418 while (reg1
<= reg2
)
14420 if (reg1
>= 4 && reg1
<= 7)
14424 nargs
|= 1 << (reg1
- 4);
14426 /* statics $a0-$a3 */
14427 statics
|= 1 << (reg1
- 4);
14429 else if ((reg1
>= 16 && reg1
<= 23) || reg1
== 30)
14432 sregs
|= 1 << ((reg1
== 30) ? 8 : (reg1
- 16));
14434 else if (reg1
== 31)
14436 /* Add $ra to insn. */
14441 as_bad (_("unexpected register in list"));
14449 /* Encode args/statics combination. */
14450 if (nargs
& statics
)
14451 as_bad (_("arg/static registers overlap"));
14452 else if (nargs
== 0xf)
14453 /* All $a0-$a3 are args. */
14454 opcode
|= MIPS16_ALL_ARGS
<< 16;
14455 else if (statics
== 0xf)
14456 /* All $a0-$a3 are statics. */
14457 opcode
|= MIPS16_ALL_STATICS
<< 16;
14460 int narg
= 0, nstat
= 0;
14462 /* Count arg registers. */
14463 while (nargs
& 0x1)
14469 as_bad (_("invalid arg register list"));
14471 /* Count static registers. */
14472 while (statics
& 0x8)
14474 statics
= (statics
<< 1) & 0xf;
14478 as_bad (_("invalid static register list"));
14480 /* Encode args/statics. */
14481 opcode
|= ((narg
<< 2) | nstat
) << 16;
14484 /* Encode $s0/$s1. */
14485 if (sregs
& (1 << 0)) /* $s0 */
14487 if (sregs
& (1 << 1)) /* $s1 */
14493 /* Count regs $s2-$s8. */
14501 as_bad (_("invalid static register list"));
14502 /* Encode $s2-$s8. */
14503 opcode
|= nsreg
<< 24;
14506 /* Encode frame size. */
14508 as_bad (_("missing frame size"));
14509 else if ((framesz
& 7) != 0 || framesz
< 0
14510 || framesz
> 0xff * 8)
14511 as_bad (_("invalid frame size"));
14512 else if (framesz
!= 128 || (opcode
>> 16) != 0)
14515 opcode
|= (((framesz
& 0xf0) << 16)
14516 | (framesz
& 0x0f));
14519 /* Finally build the instruction. */
14520 if ((opcode
>> 16) != 0 || framesz
== 0)
14521 opcode
|= MIPS16_EXTEND
;
14522 ip
->insn_opcode
= opcode
;
14526 case 'e': /* extend code */
14527 my_getExpression (&imm_expr
, s
);
14528 check_absolute_expr (ip
, &imm_expr
);
14529 if ((unsigned long) imm_expr
.X_add_number
> 0x7ff)
14531 as_warn (_("Invalid value for `%s' (%lu)"),
14533 (unsigned long) imm_expr
.X_add_number
);
14534 imm_expr
.X_add_number
&= 0x7ff;
14536 ip
->insn_opcode
|= imm_expr
.X_add_number
;
14537 imm_expr
.X_op
= O_absent
;
14547 /* Args don't match. */
14548 if (insn
+ 1 < &mips16_opcodes
[bfd_mips16_num_opcodes
] &&
14549 strcmp (insn
->name
, insn
[1].name
) == 0)
14556 insn_error
= _("illegal operands");
14562 /* This structure holds information we know about a mips16 immediate
14565 struct mips16_immed_operand
14567 /* The type code used in the argument string in the opcode table. */
14569 /* The number of bits in the short form of the opcode. */
14571 /* The number of bits in the extended form of the opcode. */
14573 /* The amount by which the short form is shifted when it is used;
14574 for example, the sw instruction has a shift count of 2. */
14576 /* The amount by which the short form is shifted when it is stored
14577 into the instruction code. */
14579 /* Non-zero if the short form is unsigned. */
14581 /* Non-zero if the extended form is unsigned. */
14583 /* Non-zero if the value is PC relative. */
14587 /* The mips16 immediate operand types. */
14589 static const struct mips16_immed_operand mips16_immed_operands
[] =
14591 { '<', 3, 5, 0, MIPS16OP_SH_RZ
, 1, 1, 0 },
14592 { '>', 3, 5, 0, MIPS16OP_SH_RX
, 1, 1, 0 },
14593 { '[', 3, 6, 0, MIPS16OP_SH_RZ
, 1, 1, 0 },
14594 { ']', 3, 6, 0, MIPS16OP_SH_RX
, 1, 1, 0 },
14595 { '4', 4, 15, 0, MIPS16OP_SH_IMM4
, 0, 0, 0 },
14596 { '5', 5, 16, 0, MIPS16OP_SH_IMM5
, 1, 0, 0 },
14597 { 'H', 5, 16, 1, MIPS16OP_SH_IMM5
, 1, 0, 0 },
14598 { 'W', 5, 16, 2, MIPS16OP_SH_IMM5
, 1, 0, 0 },
14599 { 'D', 5, 16, 3, MIPS16OP_SH_IMM5
, 1, 0, 0 },
14600 { 'j', 5, 16, 0, MIPS16OP_SH_IMM5
, 0, 0, 0 },
14601 { '8', 8, 16, 0, MIPS16OP_SH_IMM8
, 1, 0, 0 },
14602 { 'V', 8, 16, 2, MIPS16OP_SH_IMM8
, 1, 0, 0 },
14603 { 'C', 8, 16, 3, MIPS16OP_SH_IMM8
, 1, 0, 0 },
14604 { 'U', 8, 16, 0, MIPS16OP_SH_IMM8
, 1, 1, 0 },
14605 { 'k', 8, 16, 0, MIPS16OP_SH_IMM8
, 0, 0, 0 },
14606 { 'K', 8, 16, 3, MIPS16OP_SH_IMM8
, 0, 0, 0 },
14607 { 'p', 8, 16, 0, MIPS16OP_SH_IMM8
, 0, 0, 1 },
14608 { 'q', 11, 16, 0, MIPS16OP_SH_IMM8
, 0, 0, 1 },
14609 { 'A', 8, 16, 2, MIPS16OP_SH_IMM8
, 1, 0, 1 },
14610 { 'B', 5, 16, 3, MIPS16OP_SH_IMM5
, 1, 0, 1 },
14611 { 'E', 5, 16, 2, MIPS16OP_SH_IMM5
, 1, 0, 1 }
14614 #define MIPS16_NUM_IMMED \
14615 (sizeof mips16_immed_operands / sizeof mips16_immed_operands[0])
14617 /* Marshal immediate value VAL for an extended MIPS16 instruction.
14618 NBITS is the number of significant bits in VAL. */
14620 static unsigned long
14621 mips16_immed_extend (offsetT val
, unsigned int nbits
)
14626 extval
= ((val
>> 11) & 0x1f) | (val
& 0x7e0);
14629 else if (nbits
== 15)
14631 extval
= ((val
>> 11) & 0xf) | (val
& 0x7f0);
14636 extval
= ((val
& 0x1f) << 6) | (val
& 0x20);
14639 return (extval
<< 16) | val
;
14642 /* Install immediate value VAL into MIPS16 instruction *INSN,
14643 extending it if necessary. The instruction in *INSN may
14644 already be extended.
14646 RELOC is the relocation that produced VAL, or BFD_RELOC_UNUSED
14647 if none. In the former case, VAL is a 16-bit number with no
14648 defined signedness.
14650 TYPE is the type of the immediate field. USER_INSN_LENGTH
14651 is the length that the user requested, or 0 if none. */
14654 mips16_immed (char *file
, unsigned int line
, int type
,
14655 bfd_reloc_code_real_type reloc
, offsetT val
,
14656 unsigned int user_insn_length
, unsigned long *insn
)
14658 const struct mips16_immed_operand
*op
;
14659 int mintiny
, maxtiny
;
14661 op
= mips16_immed_operands
;
14662 while (op
->type
!= type
)
14665 gas_assert (op
< mips16_immed_operands
+ MIPS16_NUM_IMMED
);
14670 if (type
== '<' || type
== '>' || type
== '[' || type
== ']')
14673 maxtiny
= 1 << op
->nbits
;
14678 maxtiny
= (1 << op
->nbits
) - 1;
14680 if (reloc
!= BFD_RELOC_UNUSED
)
14685 mintiny
= - (1 << (op
->nbits
- 1));
14686 maxtiny
= (1 << (op
->nbits
- 1)) - 1;
14687 if (reloc
!= BFD_RELOC_UNUSED
)
14688 val
= SEXT_16BIT (val
);
14691 /* Branch offsets have an implicit 0 in the lowest bit. */
14692 if (type
== 'p' || type
== 'q')
14695 if ((val
& ((1 << op
->shift
) - 1)) != 0
14696 || val
< (mintiny
<< op
->shift
)
14697 || val
> (maxtiny
<< op
->shift
))
14699 /* We need an extended instruction. */
14700 if (user_insn_length
== 2)
14701 as_bad_where (file
, line
, _("invalid unextended operand value"));
14703 *insn
|= MIPS16_EXTEND
;
14705 else if (user_insn_length
== 4)
14707 /* The operand doesn't force an unextended instruction to be extended.
14708 Warn if the user wanted an extended instruction anyway. */
14709 *insn
|= MIPS16_EXTEND
;
14710 as_warn_where (file
, line
,
14711 _("extended operand requested but not required"));
14714 if (mips16_opcode_length (*insn
) == 2)
14718 insnval
= ((val
>> op
->shift
) & ((1 << op
->nbits
) - 1));
14719 insnval
<<= op
->op_shift
;
14724 long minext
, maxext
;
14726 if (reloc
== BFD_RELOC_UNUSED
)
14731 maxext
= (1 << op
->extbits
) - 1;
14735 minext
= - (1 << (op
->extbits
- 1));
14736 maxext
= (1 << (op
->extbits
- 1)) - 1;
14738 if (val
< minext
|| val
> maxext
)
14739 as_bad_where (file
, line
,
14740 _("operand value out of range for instruction"));
14743 *insn
|= mips16_immed_extend (val
, op
->extbits
);
14747 struct percent_op_match
14750 bfd_reloc_code_real_type reloc
;
14753 static const struct percent_op_match mips_percent_op
[] =
14755 {"%lo", BFD_RELOC_LO16
},
14756 {"%call_hi", BFD_RELOC_MIPS_CALL_HI16
},
14757 {"%call_lo", BFD_RELOC_MIPS_CALL_LO16
},
14758 {"%call16", BFD_RELOC_MIPS_CALL16
},
14759 {"%got_disp", BFD_RELOC_MIPS_GOT_DISP
},
14760 {"%got_page", BFD_RELOC_MIPS_GOT_PAGE
},
14761 {"%got_ofst", BFD_RELOC_MIPS_GOT_OFST
},
14762 {"%got_hi", BFD_RELOC_MIPS_GOT_HI16
},
14763 {"%got_lo", BFD_RELOC_MIPS_GOT_LO16
},
14764 {"%got", BFD_RELOC_MIPS_GOT16
},
14765 {"%gp_rel", BFD_RELOC_GPREL16
},
14766 {"%half", BFD_RELOC_16
},
14767 {"%highest", BFD_RELOC_MIPS_HIGHEST
},
14768 {"%higher", BFD_RELOC_MIPS_HIGHER
},
14769 {"%neg", BFD_RELOC_MIPS_SUB
},
14770 {"%tlsgd", BFD_RELOC_MIPS_TLS_GD
},
14771 {"%tlsldm", BFD_RELOC_MIPS_TLS_LDM
},
14772 {"%dtprel_hi", BFD_RELOC_MIPS_TLS_DTPREL_HI16
},
14773 {"%dtprel_lo", BFD_RELOC_MIPS_TLS_DTPREL_LO16
},
14774 {"%tprel_hi", BFD_RELOC_MIPS_TLS_TPREL_HI16
},
14775 {"%tprel_lo", BFD_RELOC_MIPS_TLS_TPREL_LO16
},
14776 {"%gottprel", BFD_RELOC_MIPS_TLS_GOTTPREL
},
14777 {"%hi", BFD_RELOC_HI16_S
}
14780 static const struct percent_op_match mips16_percent_op
[] =
14782 {"%lo", BFD_RELOC_MIPS16_LO16
},
14783 {"%gprel", BFD_RELOC_MIPS16_GPREL
},
14784 {"%got", BFD_RELOC_MIPS16_GOT16
},
14785 {"%call16", BFD_RELOC_MIPS16_CALL16
},
14786 {"%hi", BFD_RELOC_MIPS16_HI16_S
},
14787 {"%tlsgd", BFD_RELOC_MIPS16_TLS_GD
},
14788 {"%tlsldm", BFD_RELOC_MIPS16_TLS_LDM
},
14789 {"%dtprel_hi", BFD_RELOC_MIPS16_TLS_DTPREL_HI16
},
14790 {"%dtprel_lo", BFD_RELOC_MIPS16_TLS_DTPREL_LO16
},
14791 {"%tprel_hi", BFD_RELOC_MIPS16_TLS_TPREL_HI16
},
14792 {"%tprel_lo", BFD_RELOC_MIPS16_TLS_TPREL_LO16
},
14793 {"%gottprel", BFD_RELOC_MIPS16_TLS_GOTTPREL
}
14797 /* Return true if *STR points to a relocation operator. When returning true,
14798 move *STR over the operator and store its relocation code in *RELOC.
14799 Leave both *STR and *RELOC alone when returning false. */
14802 parse_relocation (char **str
, bfd_reloc_code_real_type
*reloc
)
14804 const struct percent_op_match
*percent_op
;
14807 if (mips_opts
.mips16
)
14809 percent_op
= mips16_percent_op
;
14810 limit
= ARRAY_SIZE (mips16_percent_op
);
14814 percent_op
= mips_percent_op
;
14815 limit
= ARRAY_SIZE (mips_percent_op
);
14818 for (i
= 0; i
< limit
; i
++)
14819 if (strncasecmp (*str
, percent_op
[i
].str
, strlen (percent_op
[i
].str
)) == 0)
14821 int len
= strlen (percent_op
[i
].str
);
14823 if (!ISSPACE ((*str
)[len
]) && (*str
)[len
] != '(')
14826 *str
+= strlen (percent_op
[i
].str
);
14827 *reloc
= percent_op
[i
].reloc
;
14829 /* Check whether the output BFD supports this relocation.
14830 If not, issue an error and fall back on something safe. */
14831 if (!bfd_reloc_type_lookup (stdoutput
, percent_op
[i
].reloc
))
14833 as_bad (_("relocation %s isn't supported by the current ABI"),
14834 percent_op
[i
].str
);
14835 *reloc
= BFD_RELOC_UNUSED
;
14843 /* Parse string STR as a 16-bit relocatable operand. Store the
14844 expression in *EP and the relocations in the array starting
14845 at RELOC. Return the number of relocation operators used.
14847 On exit, EXPR_END points to the first character after the expression. */
14850 my_getSmallExpression (expressionS
*ep
, bfd_reloc_code_real_type
*reloc
,
14853 bfd_reloc_code_real_type reversed_reloc
[3];
14854 size_t reloc_index
, i
;
14855 int crux_depth
, str_depth
;
14858 /* Search for the start of the main expression, recoding relocations
14859 in REVERSED_RELOC. End the loop with CRUX pointing to the start
14860 of the main expression and with CRUX_DEPTH containing the number
14861 of open brackets at that point. */
14868 crux_depth
= str_depth
;
14870 /* Skip over whitespace and brackets, keeping count of the number
14872 while (*str
== ' ' || *str
== '\t' || *str
== '(')
14877 && reloc_index
< (HAVE_NEWABI
? 3 : 1)
14878 && parse_relocation (&str
, &reversed_reloc
[reloc_index
]));
14880 my_getExpression (ep
, crux
);
14883 /* Match every open bracket. */
14884 while (crux_depth
> 0 && (*str
== ')' || *str
== ' ' || *str
== '\t'))
14888 if (crux_depth
> 0)
14889 as_bad (_("unclosed '('"));
14893 if (reloc_index
!= 0)
14895 prev_reloc_op_frag
= frag_now
;
14896 for (i
= 0; i
< reloc_index
; i
++)
14897 reloc
[i
] = reversed_reloc
[reloc_index
- 1 - i
];
14900 return reloc_index
;
14904 my_getExpression (expressionS
*ep
, char *str
)
14908 save_in
= input_line_pointer
;
14909 input_line_pointer
= str
;
14911 expr_end
= input_line_pointer
;
14912 input_line_pointer
= save_in
;
14916 md_atof (int type
, char *litP
, int *sizeP
)
14918 return ieee_md_atof (type
, litP
, sizeP
, target_big_endian
);
14922 md_number_to_chars (char *buf
, valueT val
, int n
)
14924 if (target_big_endian
)
14925 number_to_chars_bigendian (buf
, val
, n
);
14927 number_to_chars_littleendian (buf
, val
, n
);
14930 static int support_64bit_objects(void)
14932 const char **list
, **l
;
14935 list
= bfd_target_list ();
14936 for (l
= list
; *l
!= NULL
; l
++)
14937 if (strcmp (*l
, ELF_TARGET ("elf64-", "big")) == 0
14938 || strcmp (*l
, ELF_TARGET ("elf64-", "little")) == 0)
14940 yes
= (*l
!= NULL
);
14945 /* Set STRING_PTR (either &mips_arch_string or &mips_tune_string) to
14946 NEW_VALUE. Warn if another value was already specified. Note:
14947 we have to defer parsing the -march and -mtune arguments in order
14948 to handle 'from-abi' correctly, since the ABI might be specified
14949 in a later argument. */
14952 mips_set_option_string (const char **string_ptr
, const char *new_value
)
14954 if (*string_ptr
!= 0 && strcasecmp (*string_ptr
, new_value
) != 0)
14955 as_warn (_("A different %s was already specified, is now %s"),
14956 string_ptr
== &mips_arch_string
? "-march" : "-mtune",
14959 *string_ptr
= new_value
;
14963 md_parse_option (int c
, char *arg
)
14967 for (i
= 0; i
< ARRAY_SIZE (mips_ases
); i
++)
14968 if (c
== mips_ases
[i
].option_on
|| c
== mips_ases
[i
].option_off
)
14970 file_ase_explicit
|= mips_set_ase (&mips_ases
[i
],
14971 c
== mips_ases
[i
].option_on
);
14977 case OPTION_CONSTRUCT_FLOATS
:
14978 mips_disable_float_construction
= 0;
14981 case OPTION_NO_CONSTRUCT_FLOATS
:
14982 mips_disable_float_construction
= 1;
14994 target_big_endian
= 1;
14998 target_big_endian
= 0;
15004 else if (arg
[0] == '0')
15006 else if (arg
[0] == '1')
15016 mips_debug
= atoi (arg
);
15020 file_mips_isa
= ISA_MIPS1
;
15024 file_mips_isa
= ISA_MIPS2
;
15028 file_mips_isa
= ISA_MIPS3
;
15032 file_mips_isa
= ISA_MIPS4
;
15036 file_mips_isa
= ISA_MIPS5
;
15039 case OPTION_MIPS32
:
15040 file_mips_isa
= ISA_MIPS32
;
15043 case OPTION_MIPS32R2
:
15044 file_mips_isa
= ISA_MIPS32R2
;
15047 case OPTION_MIPS64R2
:
15048 file_mips_isa
= ISA_MIPS64R2
;
15051 case OPTION_MIPS64
:
15052 file_mips_isa
= ISA_MIPS64
;
15056 mips_set_option_string (&mips_tune_string
, arg
);
15060 mips_set_option_string (&mips_arch_string
, arg
);
15064 mips_set_option_string (&mips_arch_string
, "4650");
15065 mips_set_option_string (&mips_tune_string
, "4650");
15068 case OPTION_NO_M4650
:
15072 mips_set_option_string (&mips_arch_string
, "4010");
15073 mips_set_option_string (&mips_tune_string
, "4010");
15076 case OPTION_NO_M4010
:
15080 mips_set_option_string (&mips_arch_string
, "4100");
15081 mips_set_option_string (&mips_tune_string
, "4100");
15084 case OPTION_NO_M4100
:
15088 mips_set_option_string (&mips_arch_string
, "3900");
15089 mips_set_option_string (&mips_tune_string
, "3900");
15092 case OPTION_NO_M3900
:
15095 case OPTION_MICROMIPS
:
15096 if (mips_opts
.mips16
== 1)
15098 as_bad (_("-mmicromips cannot be used with -mips16"));
15101 mips_opts
.micromips
= 1;
15102 mips_no_prev_insn ();
15105 case OPTION_NO_MICROMIPS
:
15106 mips_opts
.micromips
= 0;
15107 mips_no_prev_insn ();
15110 case OPTION_MIPS16
:
15111 if (mips_opts
.micromips
== 1)
15113 as_bad (_("-mips16 cannot be used with -micromips"));
15116 mips_opts
.mips16
= 1;
15117 mips_no_prev_insn ();
15120 case OPTION_NO_MIPS16
:
15121 mips_opts
.mips16
= 0;
15122 mips_no_prev_insn ();
15125 case OPTION_FIX_24K
:
15129 case OPTION_NO_FIX_24K
:
15133 case OPTION_FIX_LOONGSON2F_JUMP
:
15134 mips_fix_loongson2f_jump
= TRUE
;
15137 case OPTION_NO_FIX_LOONGSON2F_JUMP
:
15138 mips_fix_loongson2f_jump
= FALSE
;
15141 case OPTION_FIX_LOONGSON2F_NOP
:
15142 mips_fix_loongson2f_nop
= TRUE
;
15145 case OPTION_NO_FIX_LOONGSON2F_NOP
:
15146 mips_fix_loongson2f_nop
= FALSE
;
15149 case OPTION_FIX_VR4120
:
15150 mips_fix_vr4120
= 1;
15153 case OPTION_NO_FIX_VR4120
:
15154 mips_fix_vr4120
= 0;
15157 case OPTION_FIX_VR4130
:
15158 mips_fix_vr4130
= 1;
15161 case OPTION_NO_FIX_VR4130
:
15162 mips_fix_vr4130
= 0;
15165 case OPTION_FIX_CN63XXP1
:
15166 mips_fix_cn63xxp1
= TRUE
;
15169 case OPTION_NO_FIX_CN63XXP1
:
15170 mips_fix_cn63xxp1
= FALSE
;
15173 case OPTION_RELAX_BRANCH
:
15174 mips_relax_branch
= 1;
15177 case OPTION_NO_RELAX_BRANCH
:
15178 mips_relax_branch
= 0;
15181 case OPTION_INSN32
:
15182 mips_opts
.insn32
= TRUE
;
15185 case OPTION_NO_INSN32
:
15186 mips_opts
.insn32
= FALSE
;
15189 case OPTION_MSHARED
:
15190 mips_in_shared
= TRUE
;
15193 case OPTION_MNO_SHARED
:
15194 mips_in_shared
= FALSE
;
15197 case OPTION_MSYM32
:
15198 mips_opts
.sym32
= TRUE
;
15201 case OPTION_MNO_SYM32
:
15202 mips_opts
.sym32
= FALSE
;
15205 /* When generating ELF code, we permit -KPIC and -call_shared to
15206 select SVR4_PIC, and -non_shared to select no PIC. This is
15207 intended to be compatible with Irix 5. */
15208 case OPTION_CALL_SHARED
:
15209 mips_pic
= SVR4_PIC
;
15210 mips_abicalls
= TRUE
;
15213 case OPTION_CALL_NONPIC
:
15215 mips_abicalls
= TRUE
;
15218 case OPTION_NON_SHARED
:
15220 mips_abicalls
= FALSE
;
15223 /* The -xgot option tells the assembler to use 32 bit offsets
15224 when accessing the got in SVR4_PIC mode. It is for Irix
15231 g_switch_value
= atoi (arg
);
15235 /* The -32, -n32 and -64 options are shortcuts for -mabi=32, -mabi=n32
15238 mips_abi
= O32_ABI
;
15242 mips_abi
= N32_ABI
;
15246 mips_abi
= N64_ABI
;
15247 if (!support_64bit_objects())
15248 as_fatal (_("No compiled in support for 64 bit object file format"));
15252 file_mips_gp32
= 1;
15256 file_mips_gp32
= 0;
15260 file_mips_fp32
= 1;
15264 file_mips_fp32
= 0;
15267 case OPTION_SINGLE_FLOAT
:
15268 file_mips_single_float
= 1;
15271 case OPTION_DOUBLE_FLOAT
:
15272 file_mips_single_float
= 0;
15275 case OPTION_SOFT_FLOAT
:
15276 file_mips_soft_float
= 1;
15279 case OPTION_HARD_FLOAT
:
15280 file_mips_soft_float
= 0;
15284 if (strcmp (arg
, "32") == 0)
15285 mips_abi
= O32_ABI
;
15286 else if (strcmp (arg
, "o64") == 0)
15287 mips_abi
= O64_ABI
;
15288 else if (strcmp (arg
, "n32") == 0)
15289 mips_abi
= N32_ABI
;
15290 else if (strcmp (arg
, "64") == 0)
15292 mips_abi
= N64_ABI
;
15293 if (! support_64bit_objects())
15294 as_fatal (_("No compiled in support for 64 bit object file "
15297 else if (strcmp (arg
, "eabi") == 0)
15298 mips_abi
= EABI_ABI
;
15301 as_fatal (_("invalid abi -mabi=%s"), arg
);
15306 case OPTION_M7000_HILO_FIX
:
15307 mips_7000_hilo_fix
= TRUE
;
15310 case OPTION_MNO_7000_HILO_FIX
:
15311 mips_7000_hilo_fix
= FALSE
;
15314 case OPTION_MDEBUG
:
15315 mips_flag_mdebug
= TRUE
;
15318 case OPTION_NO_MDEBUG
:
15319 mips_flag_mdebug
= FALSE
;
15323 mips_flag_pdr
= TRUE
;
15326 case OPTION_NO_PDR
:
15327 mips_flag_pdr
= FALSE
;
15330 case OPTION_MVXWORKS_PIC
:
15331 mips_pic
= VXWORKS_PIC
;
15338 mips_fix_loongson2f
= mips_fix_loongson2f_nop
|| mips_fix_loongson2f_jump
;
15343 /* Set up globals to generate code for the ISA or processor
15344 described by INFO. */
15347 mips_set_architecture (const struct mips_cpu_info
*info
)
15351 file_mips_arch
= info
->cpu
;
15352 mips_opts
.arch
= info
->cpu
;
15353 mips_opts
.isa
= info
->isa
;
15358 /* Likewise for tuning. */
15361 mips_set_tune (const struct mips_cpu_info
*info
)
15364 mips_tune
= info
->cpu
;
15369 mips_after_parse_args (void)
15371 const struct mips_cpu_info
*arch_info
= 0;
15372 const struct mips_cpu_info
*tune_info
= 0;
15374 /* GP relative stuff not working for PE */
15375 if (strncmp (TARGET_OS
, "pe", 2) == 0)
15377 if (g_switch_seen
&& g_switch_value
!= 0)
15378 as_bad (_("-G not supported in this configuration."));
15379 g_switch_value
= 0;
15382 if (mips_abi
== NO_ABI
)
15383 mips_abi
= MIPS_DEFAULT_ABI
;
15385 /* The following code determines the architecture and register size.
15386 Similar code was added to GCC 3.3 (see override_options() in
15387 config/mips/mips.c). The GAS and GCC code should be kept in sync
15388 as much as possible. */
15390 if (mips_arch_string
!= 0)
15391 arch_info
= mips_parse_cpu ("-march", mips_arch_string
);
15393 if (file_mips_isa
!= ISA_UNKNOWN
)
15395 /* Handle -mipsN. At this point, file_mips_isa contains the
15396 ISA level specified by -mipsN, while arch_info->isa contains
15397 the -march selection (if any). */
15398 if (arch_info
!= 0)
15400 /* -march takes precedence over -mipsN, since it is more descriptive.
15401 There's no harm in specifying both as long as the ISA levels
15403 if (file_mips_isa
!= arch_info
->isa
)
15404 as_bad (_("-%s conflicts with the other architecture options, which imply -%s"),
15405 mips_cpu_info_from_isa (file_mips_isa
)->name
,
15406 mips_cpu_info_from_isa (arch_info
->isa
)->name
);
15409 arch_info
= mips_cpu_info_from_isa (file_mips_isa
);
15412 if (arch_info
== 0)
15414 arch_info
= mips_parse_cpu ("default CPU", MIPS_CPU_STRING_DEFAULT
);
15415 gas_assert (arch_info
);
15418 if (ABI_NEEDS_64BIT_REGS (mips_abi
) && !ISA_HAS_64BIT_REGS (arch_info
->isa
))
15419 as_bad (_("-march=%s is not compatible with the selected ABI"),
15422 mips_set_architecture (arch_info
);
15424 /* Optimize for file_mips_arch, unless -mtune selects a different processor. */
15425 if (mips_tune_string
!= 0)
15426 tune_info
= mips_parse_cpu ("-mtune", mips_tune_string
);
15428 if (tune_info
== 0)
15429 mips_set_tune (arch_info
);
15431 mips_set_tune (tune_info
);
15433 if (file_mips_gp32
>= 0)
15435 /* The user specified the size of the integer registers. Make sure
15436 it agrees with the ABI and ISA. */
15437 if (file_mips_gp32
== 0 && !ISA_HAS_64BIT_REGS (mips_opts
.isa
))
15438 as_bad (_("-mgp64 used with a 32-bit processor"));
15439 else if (file_mips_gp32
== 1 && ABI_NEEDS_64BIT_REGS (mips_abi
))
15440 as_bad (_("-mgp32 used with a 64-bit ABI"));
15441 else if (file_mips_gp32
== 0 && ABI_NEEDS_32BIT_REGS (mips_abi
))
15442 as_bad (_("-mgp64 used with a 32-bit ABI"));
15446 /* Infer the integer register size from the ABI and processor.
15447 Restrict ourselves to 32-bit registers if that's all the
15448 processor has, or if the ABI cannot handle 64-bit registers. */
15449 file_mips_gp32
= (ABI_NEEDS_32BIT_REGS (mips_abi
)
15450 || !ISA_HAS_64BIT_REGS (mips_opts
.isa
));
15453 switch (file_mips_fp32
)
15457 /* No user specified float register size.
15458 ??? GAS treats single-float processors as though they had 64-bit
15459 float registers (although it complains when double-precision
15460 instructions are used). As things stand, saying they have 32-bit
15461 registers would lead to spurious "register must be even" messages.
15462 So here we assume float registers are never smaller than the
15464 if (file_mips_gp32
== 0)
15465 /* 64-bit integer registers implies 64-bit float registers. */
15466 file_mips_fp32
= 0;
15467 else if ((mips_opts
.ase
& FP64_ASES
)
15468 && ISA_HAS_64BIT_FPRS (mips_opts
.isa
))
15469 /* -mips3d and -mdmx imply 64-bit float registers, if possible. */
15470 file_mips_fp32
= 0;
15472 /* 32-bit float registers. */
15473 file_mips_fp32
= 1;
15476 /* The user specified the size of the float registers. Check if it
15477 agrees with the ABI and ISA. */
15479 if (!ISA_HAS_64BIT_FPRS (mips_opts
.isa
))
15480 as_bad (_("-mfp64 used with a 32-bit fpu"));
15481 else if (ABI_NEEDS_32BIT_REGS (mips_abi
)
15482 && !ISA_HAS_MXHC1 (mips_opts
.isa
))
15483 as_warn (_("-mfp64 used with a 32-bit ABI"));
15486 if (ABI_NEEDS_64BIT_REGS (mips_abi
))
15487 as_warn (_("-mfp32 used with a 64-bit ABI"));
15491 /* End of GCC-shared inference code. */
15493 /* This flag is set when we have a 64-bit capable CPU but use only
15494 32-bit wide registers. Note that EABI does not use it. */
15495 if (ISA_HAS_64BIT_REGS (mips_opts
.isa
)
15496 && ((mips_abi
== NO_ABI
&& file_mips_gp32
== 1)
15497 || mips_abi
== O32_ABI
))
15498 mips_32bitmode
= 1;
15500 if (mips_opts
.isa
== ISA_MIPS1
&& mips_trap
)
15501 as_bad (_("trap exception not supported at ISA 1"));
15503 /* If the selected architecture includes support for ASEs, enable
15504 generation of code for them. */
15505 if (mips_opts
.mips16
== -1)
15506 mips_opts
.mips16
= (CPU_HAS_MIPS16 (file_mips_arch
)) ? 1 : 0;
15507 if (mips_opts
.micromips
== -1)
15508 mips_opts
.micromips
= (CPU_HAS_MICROMIPS (file_mips_arch
)) ? 1 : 0;
15510 /* MIPS3D and MDMX require 64-bit FPRs, so -mfp32 should stop those
15511 ASEs from being selected implicitly. */
15512 if (file_mips_fp32
== 1)
15513 file_ase_explicit
|= ASE_MIPS3D
| ASE_MDMX
;
15515 /* If the user didn't explicitly select or deselect a particular ASE,
15516 use the default setting for the CPU. */
15517 mips_opts
.ase
|= (arch_info
->ase
& ~file_ase_explicit
);
15519 file_mips_isa
= mips_opts
.isa
;
15520 file_ase
= mips_opts
.ase
;
15521 mips_opts
.gp32
= file_mips_gp32
;
15522 mips_opts
.fp32
= file_mips_fp32
;
15523 mips_opts
.soft_float
= file_mips_soft_float
;
15524 mips_opts
.single_float
= file_mips_single_float
;
15526 mips_check_isa_supports_ases ();
15528 if (mips_flag_mdebug
< 0)
15529 mips_flag_mdebug
= 0;
15533 mips_init_after_args (void)
15535 /* initialize opcodes */
15536 bfd_mips_num_opcodes
= bfd_mips_num_builtin_opcodes
;
15537 mips_opcodes
= (struct mips_opcode
*) mips_builtin_opcodes
;
15541 md_pcrel_from (fixS
*fixP
)
15543 valueT addr
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
15544 switch (fixP
->fx_r_type
)
15546 case BFD_RELOC_MICROMIPS_7_PCREL_S1
:
15547 case BFD_RELOC_MICROMIPS_10_PCREL_S1
:
15548 /* Return the address of the delay slot. */
15551 case BFD_RELOC_MICROMIPS_16_PCREL_S1
:
15552 case BFD_RELOC_MICROMIPS_JMP
:
15553 case BFD_RELOC_16_PCREL_S2
:
15554 case BFD_RELOC_MIPS_JMP
:
15555 /* Return the address of the delay slot. */
15558 case BFD_RELOC_32_PCREL
:
15562 /* We have no relocation type for PC relative MIPS16 instructions. */
15563 if (fixP
->fx_addsy
&& S_GET_SEGMENT (fixP
->fx_addsy
) != now_seg
)
15564 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
15565 _("PC relative MIPS16 instruction references a different section"));
15570 /* This is called before the symbol table is processed. In order to
15571 work with gcc when using mips-tfile, we must keep all local labels.
15572 However, in other cases, we want to discard them. If we were
15573 called with -g, but we didn't see any debugging information, it may
15574 mean that gcc is smuggling debugging information through to
15575 mips-tfile, in which case we must generate all local labels. */
15578 mips_frob_file_before_adjust (void)
15580 #ifndef NO_ECOFF_DEBUGGING
15581 if (ECOFF_DEBUGGING
15583 && ! ecoff_debugging_seen
)
15584 flag_keep_locals
= 1;
15588 /* Sort any unmatched HI16 and GOT16 relocs so that they immediately precede
15589 the corresponding LO16 reloc. This is called before md_apply_fix and
15590 tc_gen_reloc. Unmatched relocs can only be generated by use of explicit
15591 relocation operators.
15593 For our purposes, a %lo() expression matches a %got() or %hi()
15596 (a) it refers to the same symbol; and
15597 (b) the offset applied in the %lo() expression is no lower than
15598 the offset applied in the %got() or %hi().
15600 (b) allows us to cope with code like:
15603 lh $4,%lo(foo+2)($4)
15605 ...which is legal on RELA targets, and has a well-defined behaviour
15606 if the user knows that adding 2 to "foo" will not induce a carry to
15609 When several %lo()s match a particular %got() or %hi(), we use the
15610 following rules to distinguish them:
15612 (1) %lo()s with smaller offsets are a better match than %lo()s with
15615 (2) %lo()s with no matching %got() or %hi() are better than those
15616 that already have a matching %got() or %hi().
15618 (3) later %lo()s are better than earlier %lo()s.
15620 These rules are applied in order.
15622 (1) means, among other things, that %lo()s with identical offsets are
15623 chosen if they exist.
15625 (2) means that we won't associate several high-part relocations with
15626 the same low-part relocation unless there's no alternative. Having
15627 several high parts for the same low part is a GNU extension; this rule
15628 allows careful users to avoid it.
15630 (3) is purely cosmetic. mips_hi_fixup_list is is in reverse order,
15631 with the last high-part relocation being at the front of the list.
15632 It therefore makes sense to choose the last matching low-part
15633 relocation, all other things being equal. It's also easier
15634 to code that way. */
15637 mips_frob_file (void)
15639 struct mips_hi_fixup
*l
;
15640 bfd_reloc_code_real_type looking_for_rtype
= BFD_RELOC_UNUSED
;
15642 for (l
= mips_hi_fixup_list
; l
!= NULL
; l
= l
->next
)
15644 segment_info_type
*seginfo
;
15645 bfd_boolean matched_lo_p
;
15646 fixS
**hi_pos
, **lo_pos
, **pos
;
15648 gas_assert (reloc_needs_lo_p (l
->fixp
->fx_r_type
));
15650 /* If a GOT16 relocation turns out to be against a global symbol,
15651 there isn't supposed to be a matching LO. Ignore %gots against
15652 constants; we'll report an error for those later. */
15653 if (got16_reloc_p (l
->fixp
->fx_r_type
)
15654 && !(l
->fixp
->fx_addsy
15655 && pic_need_relax (l
->fixp
->fx_addsy
, l
->seg
)))
15658 /* Check quickly whether the next fixup happens to be a matching %lo. */
15659 if (fixup_has_matching_lo_p (l
->fixp
))
15662 seginfo
= seg_info (l
->seg
);
15664 /* Set HI_POS to the position of this relocation in the chain.
15665 Set LO_POS to the position of the chosen low-part relocation.
15666 MATCHED_LO_P is true on entry to the loop if *POS is a low-part
15667 relocation that matches an immediately-preceding high-part
15671 matched_lo_p
= FALSE
;
15672 looking_for_rtype
= matching_lo_reloc (l
->fixp
->fx_r_type
);
15674 for (pos
= &seginfo
->fix_root
; *pos
!= NULL
; pos
= &(*pos
)->fx_next
)
15676 if (*pos
== l
->fixp
)
15679 if ((*pos
)->fx_r_type
== looking_for_rtype
15680 && symbol_same_p ((*pos
)->fx_addsy
, l
->fixp
->fx_addsy
)
15681 && (*pos
)->fx_offset
>= l
->fixp
->fx_offset
15683 || (*pos
)->fx_offset
< (*lo_pos
)->fx_offset
15685 && (*pos
)->fx_offset
== (*lo_pos
)->fx_offset
)))
15688 matched_lo_p
= (reloc_needs_lo_p ((*pos
)->fx_r_type
)
15689 && fixup_has_matching_lo_p (*pos
));
15692 /* If we found a match, remove the high-part relocation from its
15693 current position and insert it before the low-part relocation.
15694 Make the offsets match so that fixup_has_matching_lo_p()
15697 We don't warn about unmatched high-part relocations since some
15698 versions of gcc have been known to emit dead "lui ...%hi(...)"
15700 if (lo_pos
!= NULL
)
15702 l
->fixp
->fx_offset
= (*lo_pos
)->fx_offset
;
15703 if (l
->fixp
->fx_next
!= *lo_pos
)
15705 *hi_pos
= l
->fixp
->fx_next
;
15706 l
->fixp
->fx_next
= *lo_pos
;
15714 mips_force_relocation (fixS
*fixp
)
15716 if (generic_force_reloc (fixp
))
15719 /* We want to keep BFD_RELOC_MICROMIPS_*_PCREL_S1 relocation,
15720 so that the linker relaxation can update targets. */
15721 if (fixp
->fx_r_type
== BFD_RELOC_MICROMIPS_7_PCREL_S1
15722 || fixp
->fx_r_type
== BFD_RELOC_MICROMIPS_10_PCREL_S1
15723 || fixp
->fx_r_type
== BFD_RELOC_MICROMIPS_16_PCREL_S1
)
15729 /* Read the instruction associated with RELOC from BUF. */
15731 static unsigned int
15732 read_reloc_insn (char *buf
, bfd_reloc_code_real_type reloc
)
15734 if (mips16_reloc_p (reloc
) || micromips_reloc_p (reloc
))
15735 return read_compressed_insn (buf
, 4);
15737 return read_insn (buf
);
15740 /* Write instruction INSN to BUF, given that it has been relocated
15744 write_reloc_insn (char *buf
, bfd_reloc_code_real_type reloc
,
15745 unsigned long insn
)
15747 if (mips16_reloc_p (reloc
) || micromips_reloc_p (reloc
))
15748 write_compressed_insn (buf
, insn
, 4);
15750 write_insn (buf
, insn
);
15753 /* Apply a fixup to the object file. */
15756 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
15759 unsigned long insn
;
15760 reloc_howto_type
*howto
;
15762 /* We ignore generic BFD relocations we don't know about. */
15763 howto
= bfd_reloc_type_lookup (stdoutput
, fixP
->fx_r_type
);
15767 gas_assert (fixP
->fx_size
== 2
15768 || fixP
->fx_size
== 4
15769 || fixP
->fx_r_type
== BFD_RELOC_16
15770 || fixP
->fx_r_type
== BFD_RELOC_64
15771 || fixP
->fx_r_type
== BFD_RELOC_CTOR
15772 || fixP
->fx_r_type
== BFD_RELOC_MIPS_SUB
15773 || fixP
->fx_r_type
== BFD_RELOC_MICROMIPS_SUB
15774 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
15775 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
15776 || fixP
->fx_r_type
== BFD_RELOC_MIPS_TLS_DTPREL64
);
15778 buf
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
15780 gas_assert (!fixP
->fx_pcrel
|| fixP
->fx_r_type
== BFD_RELOC_16_PCREL_S2
15781 || fixP
->fx_r_type
== BFD_RELOC_MICROMIPS_7_PCREL_S1
15782 || fixP
->fx_r_type
== BFD_RELOC_MICROMIPS_10_PCREL_S1
15783 || fixP
->fx_r_type
== BFD_RELOC_MICROMIPS_16_PCREL_S1
15784 || fixP
->fx_r_type
== BFD_RELOC_32_PCREL
);
15786 /* Don't treat parts of a composite relocation as done. There are two
15789 (1) The second and third parts will be against 0 (RSS_UNDEF) but
15790 should nevertheless be emitted if the first part is.
15792 (2) In normal usage, composite relocations are never assembly-time
15793 constants. The easiest way of dealing with the pathological
15794 exceptions is to generate a relocation against STN_UNDEF and
15795 leave everything up to the linker. */
15796 if (fixP
->fx_addsy
== NULL
&& !fixP
->fx_pcrel
&& fixP
->fx_tcbit
== 0)
15799 switch (fixP
->fx_r_type
)
15801 case BFD_RELOC_MIPS_TLS_GD
:
15802 case BFD_RELOC_MIPS_TLS_LDM
:
15803 case BFD_RELOC_MIPS_TLS_DTPREL32
:
15804 case BFD_RELOC_MIPS_TLS_DTPREL64
:
15805 case BFD_RELOC_MIPS_TLS_DTPREL_HI16
:
15806 case BFD_RELOC_MIPS_TLS_DTPREL_LO16
:
15807 case BFD_RELOC_MIPS_TLS_GOTTPREL
:
15808 case BFD_RELOC_MIPS_TLS_TPREL32
:
15809 case BFD_RELOC_MIPS_TLS_TPREL64
:
15810 case BFD_RELOC_MIPS_TLS_TPREL_HI16
:
15811 case BFD_RELOC_MIPS_TLS_TPREL_LO16
:
15812 case BFD_RELOC_MICROMIPS_TLS_GD
:
15813 case BFD_RELOC_MICROMIPS_TLS_LDM
:
15814 case BFD_RELOC_MICROMIPS_TLS_DTPREL_HI16
:
15815 case BFD_RELOC_MICROMIPS_TLS_DTPREL_LO16
:
15816 case BFD_RELOC_MICROMIPS_TLS_GOTTPREL
:
15817 case BFD_RELOC_MICROMIPS_TLS_TPREL_HI16
:
15818 case BFD_RELOC_MICROMIPS_TLS_TPREL_LO16
:
15819 case BFD_RELOC_MIPS16_TLS_GD
:
15820 case BFD_RELOC_MIPS16_TLS_LDM
:
15821 case BFD_RELOC_MIPS16_TLS_DTPREL_HI16
:
15822 case BFD_RELOC_MIPS16_TLS_DTPREL_LO16
:
15823 case BFD_RELOC_MIPS16_TLS_GOTTPREL
:
15824 case BFD_RELOC_MIPS16_TLS_TPREL_HI16
:
15825 case BFD_RELOC_MIPS16_TLS_TPREL_LO16
:
15826 if (!fixP
->fx_addsy
)
15828 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
15829 _("TLS relocation against a constant"));
15832 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
15835 case BFD_RELOC_MIPS_JMP
:
15836 case BFD_RELOC_MIPS_SHIFT5
:
15837 case BFD_RELOC_MIPS_SHIFT6
:
15838 case BFD_RELOC_MIPS_GOT_DISP
:
15839 case BFD_RELOC_MIPS_GOT_PAGE
:
15840 case BFD_RELOC_MIPS_GOT_OFST
:
15841 case BFD_RELOC_MIPS_SUB
:
15842 case BFD_RELOC_MIPS_INSERT_A
:
15843 case BFD_RELOC_MIPS_INSERT_B
:
15844 case BFD_RELOC_MIPS_DELETE
:
15845 case BFD_RELOC_MIPS_HIGHEST
:
15846 case BFD_RELOC_MIPS_HIGHER
:
15847 case BFD_RELOC_MIPS_SCN_DISP
:
15848 case BFD_RELOC_MIPS_REL16
:
15849 case BFD_RELOC_MIPS_RELGOT
:
15850 case BFD_RELOC_MIPS_JALR
:
15851 case BFD_RELOC_HI16
:
15852 case BFD_RELOC_HI16_S
:
15853 case BFD_RELOC_LO16
:
15854 case BFD_RELOC_GPREL16
:
15855 case BFD_RELOC_MIPS_LITERAL
:
15856 case BFD_RELOC_MIPS_CALL16
:
15857 case BFD_RELOC_MIPS_GOT16
:
15858 case BFD_RELOC_GPREL32
:
15859 case BFD_RELOC_MIPS_GOT_HI16
:
15860 case BFD_RELOC_MIPS_GOT_LO16
:
15861 case BFD_RELOC_MIPS_CALL_HI16
:
15862 case BFD_RELOC_MIPS_CALL_LO16
:
15863 case BFD_RELOC_MIPS16_GPREL
:
15864 case BFD_RELOC_MIPS16_GOT16
:
15865 case BFD_RELOC_MIPS16_CALL16
:
15866 case BFD_RELOC_MIPS16_HI16
:
15867 case BFD_RELOC_MIPS16_HI16_S
:
15868 case BFD_RELOC_MIPS16_LO16
:
15869 case BFD_RELOC_MIPS16_JMP
:
15870 case BFD_RELOC_MICROMIPS_JMP
:
15871 case BFD_RELOC_MICROMIPS_GOT_DISP
:
15872 case BFD_RELOC_MICROMIPS_GOT_PAGE
:
15873 case BFD_RELOC_MICROMIPS_GOT_OFST
:
15874 case BFD_RELOC_MICROMIPS_SUB
:
15875 case BFD_RELOC_MICROMIPS_HIGHEST
:
15876 case BFD_RELOC_MICROMIPS_HIGHER
:
15877 case BFD_RELOC_MICROMIPS_SCN_DISP
:
15878 case BFD_RELOC_MICROMIPS_JALR
:
15879 case BFD_RELOC_MICROMIPS_HI16
:
15880 case BFD_RELOC_MICROMIPS_HI16_S
:
15881 case BFD_RELOC_MICROMIPS_LO16
:
15882 case BFD_RELOC_MICROMIPS_GPREL16
:
15883 case BFD_RELOC_MICROMIPS_LITERAL
:
15884 case BFD_RELOC_MICROMIPS_CALL16
:
15885 case BFD_RELOC_MICROMIPS_GOT16
:
15886 case BFD_RELOC_MICROMIPS_GOT_HI16
:
15887 case BFD_RELOC_MICROMIPS_GOT_LO16
:
15888 case BFD_RELOC_MICROMIPS_CALL_HI16
:
15889 case BFD_RELOC_MICROMIPS_CALL_LO16
:
15890 case BFD_RELOC_MIPS_EH
:
15895 if (calculate_reloc (fixP
->fx_r_type
, *valP
, &value
))
15897 insn
= read_reloc_insn (buf
, fixP
->fx_r_type
);
15898 if (mips16_reloc_p (fixP
->fx_r_type
))
15899 insn
|= mips16_immed_extend (value
, 16);
15901 insn
|= (value
& 0xffff);
15902 write_reloc_insn (buf
, fixP
->fx_r_type
, insn
);
15905 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
15906 _("Unsupported constant in relocation"));
15911 /* This is handled like BFD_RELOC_32, but we output a sign
15912 extended value if we are only 32 bits. */
15915 if (8 <= sizeof (valueT
))
15916 md_number_to_chars (buf
, *valP
, 8);
15921 if ((*valP
& 0x80000000) != 0)
15925 md_number_to_chars (buf
+ (target_big_endian
? 4 : 0), *valP
, 4);
15926 md_number_to_chars (buf
+ (target_big_endian
? 0 : 4), hiv
, 4);
15931 case BFD_RELOC_RVA
:
15933 case BFD_RELOC_32_PCREL
:
15935 /* If we are deleting this reloc entry, we must fill in the
15936 value now. This can happen if we have a .word which is not
15937 resolved when it appears but is later defined. */
15939 md_number_to_chars (buf
, *valP
, fixP
->fx_size
);
15942 case BFD_RELOC_16_PCREL_S2
:
15943 if ((*valP
& 0x3) != 0)
15944 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
15945 _("Branch to misaligned address (%lx)"), (long) *valP
);
15947 /* We need to save the bits in the instruction since fixup_segment()
15948 might be deleting the relocation entry (i.e., a branch within
15949 the current segment). */
15950 if (! fixP
->fx_done
)
15953 /* Update old instruction data. */
15954 insn
= read_insn (buf
);
15956 if (*valP
+ 0x20000 <= 0x3ffff)
15958 insn
|= (*valP
>> 2) & 0xffff;
15959 write_insn (buf
, insn
);
15961 else if (mips_pic
== NO_PIC
15963 && fixP
->fx_frag
->fr_address
>= text_section
->vma
15964 && (fixP
->fx_frag
->fr_address
15965 < text_section
->vma
+ bfd_get_section_size (text_section
))
15966 && ((insn
& 0xffff0000) == 0x10000000 /* beq $0,$0 */
15967 || (insn
& 0xffff0000) == 0x04010000 /* bgez $0 */
15968 || (insn
& 0xffff0000) == 0x04110000)) /* bgezal $0 */
15970 /* The branch offset is too large. If this is an
15971 unconditional branch, and we are not generating PIC code,
15972 we can convert it to an absolute jump instruction. */
15973 if ((insn
& 0xffff0000) == 0x04110000) /* bgezal $0 */
15974 insn
= 0x0c000000; /* jal */
15976 insn
= 0x08000000; /* j */
15977 fixP
->fx_r_type
= BFD_RELOC_MIPS_JMP
;
15979 fixP
->fx_addsy
= section_symbol (text_section
);
15980 *valP
+= md_pcrel_from (fixP
);
15981 write_insn (buf
, insn
);
15985 /* If we got here, we have branch-relaxation disabled,
15986 and there's nothing we can do to fix this instruction
15987 without turning it into a longer sequence. */
15988 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
15989 _("Branch out of range"));
15993 case BFD_RELOC_MICROMIPS_7_PCREL_S1
:
15994 case BFD_RELOC_MICROMIPS_10_PCREL_S1
:
15995 case BFD_RELOC_MICROMIPS_16_PCREL_S1
:
15996 /* We adjust the offset back to even. */
15997 if ((*valP
& 0x1) != 0)
16000 if (! fixP
->fx_done
)
16003 /* Should never visit here, because we keep the relocation. */
16007 case BFD_RELOC_VTABLE_INHERIT
:
16010 && !S_IS_DEFINED (fixP
->fx_addsy
)
16011 && !S_IS_WEAK (fixP
->fx_addsy
))
16012 S_SET_WEAK (fixP
->fx_addsy
);
16015 case BFD_RELOC_VTABLE_ENTRY
:
16023 /* Remember value for tc_gen_reloc. */
16024 fixP
->fx_addnumber
= *valP
;
16034 name
= input_line_pointer
;
16035 c
= get_symbol_end ();
16036 p
= (symbolS
*) symbol_find_or_make (name
);
16037 *input_line_pointer
= c
;
16041 /* Align the current frag to a given power of two. If a particular
16042 fill byte should be used, FILL points to an integer that contains
16043 that byte, otherwise FILL is null.
16045 This function used to have the comment:
16047 The MIPS assembler also automatically adjusts any preceding label.
16049 The implementation therefore applied the adjustment to a maximum of
16050 one label. However, other label adjustments are applied to batches
16051 of labels, and adjusting just one caused problems when new labels
16052 were added for the sake of debugging or unwind information.
16053 We therefore adjust all preceding labels (given as LABELS) instead. */
16056 mips_align (int to
, int *fill
, struct insn_label_list
*labels
)
16058 mips_emit_delays ();
16059 mips_record_compressed_mode ();
16060 if (fill
== NULL
&& subseg_text_p (now_seg
))
16061 frag_align_code (to
, 0);
16063 frag_align (to
, fill
? *fill
: 0, 0);
16064 record_alignment (now_seg
, to
);
16065 mips_move_labels (labels
, FALSE
);
16068 /* Align to a given power of two. .align 0 turns off the automatic
16069 alignment used by the data creating pseudo-ops. */
16072 s_align (int x ATTRIBUTE_UNUSED
)
16074 int temp
, fill_value
, *fill_ptr
;
16075 long max_alignment
= 28;
16077 /* o Note that the assembler pulls down any immediately preceding label
16078 to the aligned address.
16079 o It's not documented but auto alignment is reinstated by
16080 a .align pseudo instruction.
16081 o Note also that after auto alignment is turned off the mips assembler
16082 issues an error on attempt to assemble an improperly aligned data item.
16085 temp
= get_absolute_expression ();
16086 if (temp
> max_alignment
)
16087 as_bad (_("Alignment too large: %d. assumed."), temp
= max_alignment
);
16090 as_warn (_("Alignment negative: 0 assumed."));
16093 if (*input_line_pointer
== ',')
16095 ++input_line_pointer
;
16096 fill_value
= get_absolute_expression ();
16097 fill_ptr
= &fill_value
;
16103 segment_info_type
*si
= seg_info (now_seg
);
16104 struct insn_label_list
*l
= si
->label_list
;
16105 /* Auto alignment should be switched on by next section change. */
16107 mips_align (temp
, fill_ptr
, l
);
16114 demand_empty_rest_of_line ();
16118 s_change_sec (int sec
)
16122 /* The ELF backend needs to know that we are changing sections, so
16123 that .previous works correctly. We could do something like check
16124 for an obj_section_change_hook macro, but that might be confusing
16125 as it would not be appropriate to use it in the section changing
16126 functions in read.c, since obj-elf.c intercepts those. FIXME:
16127 This should be cleaner, somehow. */
16128 obj_elf_section_change_hook ();
16130 mips_emit_delays ();
16141 subseg_set (bss_section
, (subsegT
) get_absolute_expression ());
16142 demand_empty_rest_of_line ();
16146 seg
= subseg_new (RDATA_SECTION_NAME
,
16147 (subsegT
) get_absolute_expression ());
16148 bfd_set_section_flags (stdoutput
, seg
, (SEC_ALLOC
| SEC_LOAD
16149 | SEC_READONLY
| SEC_RELOC
16151 if (strncmp (TARGET_OS
, "elf", 3) != 0)
16152 record_alignment (seg
, 4);
16153 demand_empty_rest_of_line ();
16157 seg
= subseg_new (".sdata", (subsegT
) get_absolute_expression ());
16158 bfd_set_section_flags (stdoutput
, seg
,
16159 SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_DATA
);
16160 if (strncmp (TARGET_OS
, "elf", 3) != 0)
16161 record_alignment (seg
, 4);
16162 demand_empty_rest_of_line ();
16166 seg
= subseg_new (".sbss", (subsegT
) get_absolute_expression ());
16167 bfd_set_section_flags (stdoutput
, seg
, SEC_ALLOC
);
16168 if (strncmp (TARGET_OS
, "elf", 3) != 0)
16169 record_alignment (seg
, 4);
16170 demand_empty_rest_of_line ();
16178 s_change_section (int ignore ATTRIBUTE_UNUSED
)
16180 char *section_name
;
16185 int section_entry_size
;
16186 int section_alignment
;
16188 section_name
= input_line_pointer
;
16189 c
= get_symbol_end ();
16191 next_c
= *(input_line_pointer
+ 1);
16193 /* Do we have .section Name<,"flags">? */
16194 if (c
!= ',' || (c
== ',' && next_c
== '"'))
16196 /* just after name is now '\0'. */
16197 *input_line_pointer
= c
;
16198 input_line_pointer
= section_name
;
16199 obj_elf_section (ignore
);
16202 input_line_pointer
++;
16204 /* Do we have .section Name<,type><,flag><,entry_size><,alignment> */
16206 section_type
= get_absolute_expression ();
16209 if (*input_line_pointer
++ == ',')
16210 section_flag
= get_absolute_expression ();
16213 if (*input_line_pointer
++ == ',')
16214 section_entry_size
= get_absolute_expression ();
16216 section_entry_size
= 0;
16217 if (*input_line_pointer
++ == ',')
16218 section_alignment
= get_absolute_expression ();
16220 section_alignment
= 0;
16221 /* FIXME: really ignore? */
16222 (void) section_alignment
;
16224 section_name
= xstrdup (section_name
);
16226 /* When using the generic form of .section (as implemented by obj-elf.c),
16227 there's no way to set the section type to SHT_MIPS_DWARF. Users have
16228 traditionally had to fall back on the more common @progbits instead.
16230 There's nothing really harmful in this, since bfd will correct
16231 SHT_PROGBITS to SHT_MIPS_DWARF before writing out the file. But it
16232 means that, for backwards compatibility, the special_section entries
16233 for dwarf sections must use SHT_PROGBITS rather than SHT_MIPS_DWARF.
16235 Even so, we shouldn't force users of the MIPS .section syntax to
16236 incorrectly label the sections as SHT_PROGBITS. The best compromise
16237 seems to be to map SHT_MIPS_DWARF to SHT_PROGBITS before calling the
16238 generic type-checking code. */
16239 if (section_type
== SHT_MIPS_DWARF
)
16240 section_type
= SHT_PROGBITS
;
16242 obj_elf_change_section (section_name
, section_type
, section_flag
,
16243 section_entry_size
, 0, 0, 0);
16245 if (now_seg
->name
!= section_name
)
16246 free (section_name
);
16250 mips_enable_auto_align (void)
16256 s_cons (int log_size
)
16258 segment_info_type
*si
= seg_info (now_seg
);
16259 struct insn_label_list
*l
= si
->label_list
;
16261 mips_emit_delays ();
16262 if (log_size
> 0 && auto_align
)
16263 mips_align (log_size
, 0, l
);
16264 cons (1 << log_size
);
16265 mips_clear_insn_labels ();
16269 s_float_cons (int type
)
16271 segment_info_type
*si
= seg_info (now_seg
);
16272 struct insn_label_list
*l
= si
->label_list
;
16274 mips_emit_delays ();
16279 mips_align (3, 0, l
);
16281 mips_align (2, 0, l
);
16285 mips_clear_insn_labels ();
16288 /* Handle .globl. We need to override it because on Irix 5 you are
16291 where foo is an undefined symbol, to mean that foo should be
16292 considered to be the address of a function. */
16295 s_mips_globl (int x ATTRIBUTE_UNUSED
)
16304 name
= input_line_pointer
;
16305 c
= get_symbol_end ();
16306 symbolP
= symbol_find_or_make (name
);
16307 S_SET_EXTERNAL (symbolP
);
16309 *input_line_pointer
= c
;
16310 SKIP_WHITESPACE ();
16312 /* On Irix 5, every global symbol that is not explicitly labelled as
16313 being a function is apparently labelled as being an object. */
16316 if (!is_end_of_line
[(unsigned char) *input_line_pointer
]
16317 && (*input_line_pointer
!= ','))
16322 secname
= input_line_pointer
;
16323 c
= get_symbol_end ();
16324 sec
= bfd_get_section_by_name (stdoutput
, secname
);
16326 as_bad (_("%s: no such section"), secname
);
16327 *input_line_pointer
= c
;
16329 if (sec
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
16330 flag
= BSF_FUNCTION
;
16333 symbol_get_bfdsym (symbolP
)->flags
|= flag
;
16335 c
= *input_line_pointer
;
16338 input_line_pointer
++;
16339 SKIP_WHITESPACE ();
16340 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
16346 demand_empty_rest_of_line ();
16350 s_option (int x ATTRIBUTE_UNUSED
)
16355 opt
= input_line_pointer
;
16356 c
= get_symbol_end ();
16360 /* FIXME: What does this mean? */
16362 else if (strncmp (opt
, "pic", 3) == 0)
16366 i
= atoi (opt
+ 3);
16371 mips_pic
= SVR4_PIC
;
16372 mips_abicalls
= TRUE
;
16375 as_bad (_(".option pic%d not supported"), i
);
16377 if (mips_pic
== SVR4_PIC
)
16379 if (g_switch_seen
&& g_switch_value
!= 0)
16380 as_warn (_("-G may not be used with SVR4 PIC code"));
16381 g_switch_value
= 0;
16382 bfd_set_gp_size (stdoutput
, 0);
16386 as_warn (_("Unrecognized option \"%s\""), opt
);
16388 *input_line_pointer
= c
;
16389 demand_empty_rest_of_line ();
16392 /* This structure is used to hold a stack of .set values. */
16394 struct mips_option_stack
16396 struct mips_option_stack
*next
;
16397 struct mips_set_options options
;
16400 static struct mips_option_stack
*mips_opts_stack
;
16402 /* Handle the .set pseudo-op. */
16405 s_mipsset (int x ATTRIBUTE_UNUSED
)
16407 char *name
= input_line_pointer
, ch
;
16408 const struct mips_ase
*ase
;
16410 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
16411 ++input_line_pointer
;
16412 ch
= *input_line_pointer
;
16413 *input_line_pointer
= '\0';
16415 if (strcmp (name
, "reorder") == 0)
16417 if (mips_opts
.noreorder
)
16420 else if (strcmp (name
, "noreorder") == 0)
16422 if (!mips_opts
.noreorder
)
16423 start_noreorder ();
16425 else if (strncmp (name
, "at=", 3) == 0)
16427 char *s
= name
+ 3;
16429 if (!reg_lookup (&s
, RTYPE_NUM
| RTYPE_GP
, &mips_opts
.at
))
16430 as_bad (_("Unrecognized register name `%s'"), s
);
16432 else if (strcmp (name
, "at") == 0)
16434 mips_opts
.at
= ATREG
;
16436 else if (strcmp (name
, "noat") == 0)
16438 mips_opts
.at
= ZERO
;
16440 else if (strcmp (name
, "macro") == 0)
16442 mips_opts
.warn_about_macros
= 0;
16444 else if (strcmp (name
, "nomacro") == 0)
16446 if (mips_opts
.noreorder
== 0)
16447 as_bad (_("`noreorder' must be set before `nomacro'"));
16448 mips_opts
.warn_about_macros
= 1;
16450 else if (strcmp (name
, "move") == 0 || strcmp (name
, "novolatile") == 0)
16452 mips_opts
.nomove
= 0;
16454 else if (strcmp (name
, "nomove") == 0 || strcmp (name
, "volatile") == 0)
16456 mips_opts
.nomove
= 1;
16458 else if (strcmp (name
, "bopt") == 0)
16460 mips_opts
.nobopt
= 0;
16462 else if (strcmp (name
, "nobopt") == 0)
16464 mips_opts
.nobopt
= 1;
16466 else if (strcmp (name
, "gp=default") == 0)
16467 mips_opts
.gp32
= file_mips_gp32
;
16468 else if (strcmp (name
, "gp=32") == 0)
16469 mips_opts
.gp32
= 1;
16470 else if (strcmp (name
, "gp=64") == 0)
16472 if (!ISA_HAS_64BIT_REGS (mips_opts
.isa
))
16473 as_warn (_("%s isa does not support 64-bit registers"),
16474 mips_cpu_info_from_isa (mips_opts
.isa
)->name
);
16475 mips_opts
.gp32
= 0;
16477 else if (strcmp (name
, "fp=default") == 0)
16478 mips_opts
.fp32
= file_mips_fp32
;
16479 else if (strcmp (name
, "fp=32") == 0)
16480 mips_opts
.fp32
= 1;
16481 else if (strcmp (name
, "fp=64") == 0)
16483 if (!ISA_HAS_64BIT_FPRS (mips_opts
.isa
))
16484 as_warn (_("%s isa does not support 64-bit floating point registers"),
16485 mips_cpu_info_from_isa (mips_opts
.isa
)->name
);
16486 mips_opts
.fp32
= 0;
16488 else if (strcmp (name
, "softfloat") == 0)
16489 mips_opts
.soft_float
= 1;
16490 else if (strcmp (name
, "hardfloat") == 0)
16491 mips_opts
.soft_float
= 0;
16492 else if (strcmp (name
, "singlefloat") == 0)
16493 mips_opts
.single_float
= 1;
16494 else if (strcmp (name
, "doublefloat") == 0)
16495 mips_opts
.single_float
= 0;
16496 else if (strcmp (name
, "mips16") == 0
16497 || strcmp (name
, "MIPS-16") == 0)
16499 if (mips_opts
.micromips
== 1)
16500 as_fatal (_("`mips16' cannot be used with `micromips'"));
16501 mips_opts
.mips16
= 1;
16503 else if (strcmp (name
, "nomips16") == 0
16504 || strcmp (name
, "noMIPS-16") == 0)
16505 mips_opts
.mips16
= 0;
16506 else if (strcmp (name
, "micromips") == 0)
16508 if (mips_opts
.mips16
== 1)
16509 as_fatal (_("`micromips' cannot be used with `mips16'"));
16510 mips_opts
.micromips
= 1;
16512 else if (strcmp (name
, "nomicromips") == 0)
16513 mips_opts
.micromips
= 0;
16514 else if (name
[0] == 'n'
16516 && (ase
= mips_lookup_ase (name
+ 2)))
16517 mips_set_ase (ase
, FALSE
);
16518 else if ((ase
= mips_lookup_ase (name
)))
16519 mips_set_ase (ase
, TRUE
);
16520 else if (strncmp (name
, "mips", 4) == 0 || strncmp (name
, "arch=", 5) == 0)
16524 /* Permit the user to change the ISA and architecture on the fly.
16525 Needless to say, misuse can cause serious problems. */
16526 if (strcmp (name
, "mips0") == 0 || strcmp (name
, "arch=default") == 0)
16529 mips_opts
.isa
= file_mips_isa
;
16530 mips_opts
.arch
= file_mips_arch
;
16532 else if (strncmp (name
, "arch=", 5) == 0)
16534 const struct mips_cpu_info
*p
;
16536 p
= mips_parse_cpu("internal use", name
+ 5);
16538 as_bad (_("unknown architecture %s"), name
+ 5);
16541 mips_opts
.arch
= p
->cpu
;
16542 mips_opts
.isa
= p
->isa
;
16545 else if (strncmp (name
, "mips", 4) == 0)
16547 const struct mips_cpu_info
*p
;
16549 p
= mips_parse_cpu("internal use", name
);
16551 as_bad (_("unknown ISA level %s"), name
+ 4);
16554 mips_opts
.arch
= p
->cpu
;
16555 mips_opts
.isa
= p
->isa
;
16559 as_bad (_("unknown ISA or architecture %s"), name
);
16561 switch (mips_opts
.isa
)
16569 mips_opts
.gp32
= 1;
16570 mips_opts
.fp32
= 1;
16577 mips_opts
.gp32
= 0;
16578 if (mips_opts
.arch
== CPU_R5900
)
16580 mips_opts
.fp32
= 1;
16584 mips_opts
.fp32
= 0;
16588 as_bad (_("unknown ISA level %s"), name
+ 4);
16593 mips_opts
.gp32
= file_mips_gp32
;
16594 mips_opts
.fp32
= file_mips_fp32
;
16597 else if (strcmp (name
, "autoextend") == 0)
16598 mips_opts
.noautoextend
= 0;
16599 else if (strcmp (name
, "noautoextend") == 0)
16600 mips_opts
.noautoextend
= 1;
16601 else if (strcmp (name
, "insn32") == 0)
16602 mips_opts
.insn32
= TRUE
;
16603 else if (strcmp (name
, "noinsn32") == 0)
16604 mips_opts
.insn32
= FALSE
;
16605 else if (strcmp (name
, "push") == 0)
16607 struct mips_option_stack
*s
;
16609 s
= (struct mips_option_stack
*) xmalloc (sizeof *s
);
16610 s
->next
= mips_opts_stack
;
16611 s
->options
= mips_opts
;
16612 mips_opts_stack
= s
;
16614 else if (strcmp (name
, "pop") == 0)
16616 struct mips_option_stack
*s
;
16618 s
= mips_opts_stack
;
16620 as_bad (_(".set pop with no .set push"));
16623 /* If we're changing the reorder mode we need to handle
16624 delay slots correctly. */
16625 if (s
->options
.noreorder
&& ! mips_opts
.noreorder
)
16626 start_noreorder ();
16627 else if (! s
->options
.noreorder
&& mips_opts
.noreorder
)
16630 mips_opts
= s
->options
;
16631 mips_opts_stack
= s
->next
;
16635 else if (strcmp (name
, "sym32") == 0)
16636 mips_opts
.sym32
= TRUE
;
16637 else if (strcmp (name
, "nosym32") == 0)
16638 mips_opts
.sym32
= FALSE
;
16639 else if (strchr (name
, ','))
16641 /* Generic ".set" directive; use the generic handler. */
16642 *input_line_pointer
= ch
;
16643 input_line_pointer
= name
;
16649 as_warn (_("Tried to set unrecognized symbol: %s\n"), name
);
16651 mips_check_isa_supports_ases ();
16652 *input_line_pointer
= ch
;
16653 demand_empty_rest_of_line ();
16656 /* Handle the .abicalls pseudo-op. I believe this is equivalent to
16657 .option pic2. It means to generate SVR4 PIC calls. */
16660 s_abicalls (int ignore ATTRIBUTE_UNUSED
)
16662 mips_pic
= SVR4_PIC
;
16663 mips_abicalls
= TRUE
;
16665 if (g_switch_seen
&& g_switch_value
!= 0)
16666 as_warn (_("-G may not be used with SVR4 PIC code"));
16667 g_switch_value
= 0;
16669 bfd_set_gp_size (stdoutput
, 0);
16670 demand_empty_rest_of_line ();
16673 /* Handle the .cpload pseudo-op. This is used when generating SVR4
16674 PIC code. It sets the $gp register for the function based on the
16675 function address, which is in the register named in the argument.
16676 This uses a relocation against _gp_disp, which is handled specially
16677 by the linker. The result is:
16678 lui $gp,%hi(_gp_disp)
16679 addiu $gp,$gp,%lo(_gp_disp)
16680 addu $gp,$gp,.cpload argument
16681 The .cpload argument is normally $25 == $t9.
16683 The -mno-shared option changes this to:
16684 lui $gp,%hi(__gnu_local_gp)
16685 addiu $gp,$gp,%lo(__gnu_local_gp)
16686 and the argument is ignored. This saves an instruction, but the
16687 resulting code is not position independent; it uses an absolute
16688 address for __gnu_local_gp. Thus code assembled with -mno-shared
16689 can go into an ordinary executable, but not into a shared library. */
16692 s_cpload (int ignore ATTRIBUTE_UNUSED
)
16698 /* If we are not generating SVR4 PIC code, or if this is NewABI code,
16699 .cpload is ignored. */
16700 if (mips_pic
!= SVR4_PIC
|| HAVE_NEWABI
)
16706 if (mips_opts
.mips16
)
16708 as_bad (_("%s not supported in MIPS16 mode"), ".cpload");
16709 ignore_rest_of_line ();
16713 /* .cpload should be in a .set noreorder section. */
16714 if (mips_opts
.noreorder
== 0)
16715 as_warn (_(".cpload not in noreorder section"));
16717 reg
= tc_get_register (0);
16719 /* If we need to produce a 64-bit address, we are better off using
16720 the default instruction sequence. */
16721 in_shared
= mips_in_shared
|| HAVE_64BIT_SYMBOLS
;
16723 ex
.X_op
= O_symbol
;
16724 ex
.X_add_symbol
= symbol_find_or_make (in_shared
? "_gp_disp" :
16726 ex
.X_op_symbol
= NULL
;
16727 ex
.X_add_number
= 0;
16729 /* In ELF, this symbol is implicitly an STT_OBJECT symbol. */
16730 symbol_get_bfdsym (ex
.X_add_symbol
)->flags
|= BSF_OBJECT
;
16732 mips_mark_labels ();
16733 mips_assembling_insn
= TRUE
;
16736 macro_build_lui (&ex
, mips_gp_register
);
16737 macro_build (&ex
, "addiu", "t,r,j", mips_gp_register
,
16738 mips_gp_register
, BFD_RELOC_LO16
);
16740 macro_build (NULL
, "addu", "d,v,t", mips_gp_register
,
16741 mips_gp_register
, reg
);
16744 mips_assembling_insn
= FALSE
;
16745 demand_empty_rest_of_line ();
16748 /* Handle the .cpsetup pseudo-op defined for NewABI PIC code. The syntax is:
16749 .cpsetup $reg1, offset|$reg2, label
16751 If offset is given, this results in:
16752 sd $gp, offset($sp)
16753 lui $gp, %hi(%neg(%gp_rel(label)))
16754 addiu $gp, $gp, %lo(%neg(%gp_rel(label)))
16755 daddu $gp, $gp, $reg1
16757 If $reg2 is given, this results in:
16758 daddu $reg2, $gp, $0
16759 lui $gp, %hi(%neg(%gp_rel(label)))
16760 addiu $gp, $gp, %lo(%neg(%gp_rel(label)))
16761 daddu $gp, $gp, $reg1
16762 $reg1 is normally $25 == $t9.
16764 The -mno-shared option replaces the last three instructions with
16766 addiu $gp,$gp,%lo(_gp) */
16769 s_cpsetup (int ignore ATTRIBUTE_UNUSED
)
16771 expressionS ex_off
;
16772 expressionS ex_sym
;
16775 /* If we are not generating SVR4 PIC code, .cpsetup is ignored.
16776 We also need NewABI support. */
16777 if (mips_pic
!= SVR4_PIC
|| ! HAVE_NEWABI
)
16783 if (mips_opts
.mips16
)
16785 as_bad (_("%s not supported in MIPS16 mode"), ".cpsetup");
16786 ignore_rest_of_line ();
16790 reg1
= tc_get_register (0);
16791 SKIP_WHITESPACE ();
16792 if (*input_line_pointer
!= ',')
16794 as_bad (_("missing argument separator ',' for .cpsetup"));
16798 ++input_line_pointer
;
16799 SKIP_WHITESPACE ();
16800 if (*input_line_pointer
== '$')
16802 mips_cpreturn_register
= tc_get_register (0);
16803 mips_cpreturn_offset
= -1;
16807 mips_cpreturn_offset
= get_absolute_expression ();
16808 mips_cpreturn_register
= -1;
16810 SKIP_WHITESPACE ();
16811 if (*input_line_pointer
!= ',')
16813 as_bad (_("missing argument separator ',' for .cpsetup"));
16817 ++input_line_pointer
;
16818 SKIP_WHITESPACE ();
16819 expression (&ex_sym
);
16821 mips_mark_labels ();
16822 mips_assembling_insn
= TRUE
;
16825 if (mips_cpreturn_register
== -1)
16827 ex_off
.X_op
= O_constant
;
16828 ex_off
.X_add_symbol
= NULL
;
16829 ex_off
.X_op_symbol
= NULL
;
16830 ex_off
.X_add_number
= mips_cpreturn_offset
;
16832 macro_build (&ex_off
, "sd", "t,o(b)", mips_gp_register
,
16833 BFD_RELOC_LO16
, SP
);
16836 macro_build (NULL
, "daddu", "d,v,t", mips_cpreturn_register
,
16837 mips_gp_register
, 0);
16839 if (mips_in_shared
|| HAVE_64BIT_SYMBOLS
)
16841 macro_build (&ex_sym
, "lui", LUI_FMT
, mips_gp_register
,
16842 -1, BFD_RELOC_GPREL16
, BFD_RELOC_MIPS_SUB
,
16845 macro_build (&ex_sym
, "addiu", "t,r,j", mips_gp_register
,
16846 mips_gp_register
, -1, BFD_RELOC_GPREL16
,
16847 BFD_RELOC_MIPS_SUB
, BFD_RELOC_LO16
);
16849 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t", mips_gp_register
,
16850 mips_gp_register
, reg1
);
16856 ex
.X_op
= O_symbol
;
16857 ex
.X_add_symbol
= symbol_find_or_make ("__gnu_local_gp");
16858 ex
.X_op_symbol
= NULL
;
16859 ex
.X_add_number
= 0;
16861 /* In ELF, this symbol is implicitly an STT_OBJECT symbol. */
16862 symbol_get_bfdsym (ex
.X_add_symbol
)->flags
|= BSF_OBJECT
;
16864 macro_build_lui (&ex
, mips_gp_register
);
16865 macro_build (&ex
, "addiu", "t,r,j", mips_gp_register
,
16866 mips_gp_register
, BFD_RELOC_LO16
);
16871 mips_assembling_insn
= FALSE
;
16872 demand_empty_rest_of_line ();
16876 s_cplocal (int ignore ATTRIBUTE_UNUSED
)
16878 /* If we are not generating SVR4 PIC code, or if this is not NewABI code,
16879 .cplocal is ignored. */
16880 if (mips_pic
!= SVR4_PIC
|| ! HAVE_NEWABI
)
16886 if (mips_opts
.mips16
)
16888 as_bad (_("%s not supported in MIPS16 mode"), ".cplocal");
16889 ignore_rest_of_line ();
16893 mips_gp_register
= tc_get_register (0);
16894 demand_empty_rest_of_line ();
16897 /* Handle the .cprestore pseudo-op. This stores $gp into a given
16898 offset from $sp. The offset is remembered, and after making a PIC
16899 call $gp is restored from that location. */
16902 s_cprestore (int ignore ATTRIBUTE_UNUSED
)
16906 /* If we are not generating SVR4 PIC code, or if this is NewABI code,
16907 .cprestore is ignored. */
16908 if (mips_pic
!= SVR4_PIC
|| HAVE_NEWABI
)
16914 if (mips_opts
.mips16
)
16916 as_bad (_("%s not supported in MIPS16 mode"), ".cprestore");
16917 ignore_rest_of_line ();
16921 mips_cprestore_offset
= get_absolute_expression ();
16922 mips_cprestore_valid
= 1;
16924 ex
.X_op
= O_constant
;
16925 ex
.X_add_symbol
= NULL
;
16926 ex
.X_op_symbol
= NULL
;
16927 ex
.X_add_number
= mips_cprestore_offset
;
16929 mips_mark_labels ();
16930 mips_assembling_insn
= TRUE
;
16933 macro_build_ldst_constoffset (&ex
, ADDRESS_STORE_INSN
, mips_gp_register
,
16934 SP
, HAVE_64BIT_ADDRESSES
);
16937 mips_assembling_insn
= FALSE
;
16938 demand_empty_rest_of_line ();
16941 /* Handle the .cpreturn pseudo-op defined for NewABI PIC code. If an offset
16942 was given in the preceding .cpsetup, it results in:
16943 ld $gp, offset($sp)
16945 If a register $reg2 was given there, it results in:
16946 daddu $gp, $reg2, $0 */
16949 s_cpreturn (int ignore ATTRIBUTE_UNUSED
)
16953 /* If we are not generating SVR4 PIC code, .cpreturn is ignored.
16954 We also need NewABI support. */
16955 if (mips_pic
!= SVR4_PIC
|| ! HAVE_NEWABI
)
16961 if (mips_opts
.mips16
)
16963 as_bad (_("%s not supported in MIPS16 mode"), ".cpreturn");
16964 ignore_rest_of_line ();
16968 mips_mark_labels ();
16969 mips_assembling_insn
= TRUE
;
16972 if (mips_cpreturn_register
== -1)
16974 ex
.X_op
= O_constant
;
16975 ex
.X_add_symbol
= NULL
;
16976 ex
.X_op_symbol
= NULL
;
16977 ex
.X_add_number
= mips_cpreturn_offset
;
16979 macro_build (&ex
, "ld", "t,o(b)", mips_gp_register
, BFD_RELOC_LO16
, SP
);
16982 macro_build (NULL
, "daddu", "d,v,t", mips_gp_register
,
16983 mips_cpreturn_register
, 0);
16986 mips_assembling_insn
= FALSE
;
16987 demand_empty_rest_of_line ();
16990 /* Handle a .dtprelword, .dtpreldword, .tprelword, or .tpreldword
16991 pseudo-op; DIRSTR says which. The pseudo-op generates a BYTES-size
16992 DTP- or TP-relative relocation of type RTYPE, for use in either DWARF
16993 debug information or MIPS16 TLS. */
16996 s_tls_rel_directive (const size_t bytes
, const char *dirstr
,
16997 bfd_reloc_code_real_type rtype
)
17004 if (ex
.X_op
!= O_symbol
)
17006 as_bad (_("Unsupported use of %s"), dirstr
);
17007 ignore_rest_of_line ();
17010 p
= frag_more (bytes
);
17011 md_number_to_chars (p
, 0, bytes
);
17012 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, bytes
, &ex
, FALSE
, rtype
);
17013 demand_empty_rest_of_line ();
17014 mips_clear_insn_labels ();
17017 /* Handle .dtprelword. */
17020 s_dtprelword (int ignore ATTRIBUTE_UNUSED
)
17022 s_tls_rel_directive (4, ".dtprelword", BFD_RELOC_MIPS_TLS_DTPREL32
);
17025 /* Handle .dtpreldword. */
17028 s_dtpreldword (int ignore ATTRIBUTE_UNUSED
)
17030 s_tls_rel_directive (8, ".dtpreldword", BFD_RELOC_MIPS_TLS_DTPREL64
);
17033 /* Handle .tprelword. */
17036 s_tprelword (int ignore ATTRIBUTE_UNUSED
)
17038 s_tls_rel_directive (4, ".tprelword", BFD_RELOC_MIPS_TLS_TPREL32
);
17041 /* Handle .tpreldword. */
17044 s_tpreldword (int ignore ATTRIBUTE_UNUSED
)
17046 s_tls_rel_directive (8, ".tpreldword", BFD_RELOC_MIPS_TLS_TPREL64
);
17049 /* Handle the .gpvalue pseudo-op. This is used when generating NewABI PIC
17050 code. It sets the offset to use in gp_rel relocations. */
17053 s_gpvalue (int ignore ATTRIBUTE_UNUSED
)
17055 /* If we are not generating SVR4 PIC code, .gpvalue is ignored.
17056 We also need NewABI support. */
17057 if (mips_pic
!= SVR4_PIC
|| ! HAVE_NEWABI
)
17063 mips_gprel_offset
= get_absolute_expression ();
17065 demand_empty_rest_of_line ();
17068 /* Handle the .gpword pseudo-op. This is used when generating PIC
17069 code. It generates a 32 bit GP relative reloc. */
17072 s_gpword (int ignore ATTRIBUTE_UNUSED
)
17074 segment_info_type
*si
;
17075 struct insn_label_list
*l
;
17079 /* When not generating PIC code, this is treated as .word. */
17080 if (mips_pic
!= SVR4_PIC
)
17086 si
= seg_info (now_seg
);
17087 l
= si
->label_list
;
17088 mips_emit_delays ();
17090 mips_align (2, 0, l
);
17093 mips_clear_insn_labels ();
17095 if (ex
.X_op
!= O_symbol
|| ex
.X_add_number
!= 0)
17097 as_bad (_("Unsupported use of .gpword"));
17098 ignore_rest_of_line ();
17102 md_number_to_chars (p
, 0, 4);
17103 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 4, &ex
, FALSE
,
17104 BFD_RELOC_GPREL32
);
17106 demand_empty_rest_of_line ();
17110 s_gpdword (int ignore ATTRIBUTE_UNUSED
)
17112 segment_info_type
*si
;
17113 struct insn_label_list
*l
;
17117 /* When not generating PIC code, this is treated as .dword. */
17118 if (mips_pic
!= SVR4_PIC
)
17124 si
= seg_info (now_seg
);
17125 l
= si
->label_list
;
17126 mips_emit_delays ();
17128 mips_align (3, 0, l
);
17131 mips_clear_insn_labels ();
17133 if (ex
.X_op
!= O_symbol
|| ex
.X_add_number
!= 0)
17135 as_bad (_("Unsupported use of .gpdword"));
17136 ignore_rest_of_line ();
17140 md_number_to_chars (p
, 0, 8);
17141 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 4, &ex
, FALSE
,
17142 BFD_RELOC_GPREL32
)->fx_tcbit
= 1;
17144 /* GPREL32 composed with 64 gives a 64-bit GP offset. */
17145 fix_new (frag_now
, p
- frag_now
->fr_literal
, 8, NULL
, 0,
17146 FALSE
, BFD_RELOC_64
)->fx_tcbit
= 1;
17148 demand_empty_rest_of_line ();
17151 /* Handle the .ehword pseudo-op. This is used when generating unwinding
17152 tables. It generates a R_MIPS_EH reloc. */
17155 s_ehword (int ignore ATTRIBUTE_UNUSED
)
17160 mips_emit_delays ();
17163 mips_clear_insn_labels ();
17165 if (ex
.X_op
!= O_symbol
|| ex
.X_add_number
!= 0)
17167 as_bad (_("Unsupported use of .ehword"));
17168 ignore_rest_of_line ();
17172 md_number_to_chars (p
, 0, 4);
17173 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 4, &ex
, FALSE
,
17174 BFD_RELOC_MIPS_EH
);
17176 demand_empty_rest_of_line ();
17179 /* Handle the .cpadd pseudo-op. This is used when dealing with switch
17180 tables in SVR4 PIC code. */
17183 s_cpadd (int ignore ATTRIBUTE_UNUSED
)
17187 /* This is ignored when not generating SVR4 PIC code. */
17188 if (mips_pic
!= SVR4_PIC
)
17194 mips_mark_labels ();
17195 mips_assembling_insn
= TRUE
;
17197 /* Add $gp to the register named as an argument. */
17199 reg
= tc_get_register (0);
17200 macro_build (NULL
, ADDRESS_ADD_INSN
, "d,v,t", reg
, reg
, mips_gp_register
);
17203 mips_assembling_insn
= FALSE
;
17204 demand_empty_rest_of_line ();
17207 /* Handle the .insn pseudo-op. This marks instruction labels in
17208 mips16/micromips mode. This permits the linker to handle them specially,
17209 such as generating jalx instructions when needed. We also make
17210 them odd for the duration of the assembly, in order to generate the
17211 right sort of code. We will make them even in the adjust_symtab
17212 routine, while leaving them marked. This is convenient for the
17213 debugger and the disassembler. The linker knows to make them odd
17217 s_insn (int ignore ATTRIBUTE_UNUSED
)
17219 mips_mark_labels ();
17221 demand_empty_rest_of_line ();
17224 /* Handle a .stab[snd] directive. Ideally these directives would be
17225 implemented in a transparent way, so that removing them would not
17226 have any effect on the generated instructions. However, s_stab
17227 internally changes the section, so in practice we need to decide
17228 now whether the preceding label marks compressed code. We do not
17229 support changing the compression mode of a label after a .stab*
17230 directive, such as in:
17236 so the current mode wins. */
17239 s_mips_stab (int type
)
17241 mips_mark_labels ();
17245 /* Handle the .weakext pseudo-op as defined in Kane and Heinrich. */
17248 s_mips_weakext (int ignore ATTRIBUTE_UNUSED
)
17255 name
= input_line_pointer
;
17256 c
= get_symbol_end ();
17257 symbolP
= symbol_find_or_make (name
);
17258 S_SET_WEAK (symbolP
);
17259 *input_line_pointer
= c
;
17261 SKIP_WHITESPACE ();
17263 if (! is_end_of_line
[(unsigned char) *input_line_pointer
])
17265 if (S_IS_DEFINED (symbolP
))
17267 as_bad (_("ignoring attempt to redefine symbol %s"),
17268 S_GET_NAME (symbolP
));
17269 ignore_rest_of_line ();
17273 if (*input_line_pointer
== ',')
17275 ++input_line_pointer
;
17276 SKIP_WHITESPACE ();
17280 if (exp
.X_op
!= O_symbol
)
17282 as_bad (_("bad .weakext directive"));
17283 ignore_rest_of_line ();
17286 symbol_set_value_expression (symbolP
, &exp
);
17289 demand_empty_rest_of_line ();
17292 /* Parse a register string into a number. Called from the ECOFF code
17293 to parse .frame. The argument is non-zero if this is the frame
17294 register, so that we can record it in mips_frame_reg. */
17297 tc_get_register (int frame
)
17301 SKIP_WHITESPACE ();
17302 if (! reg_lookup (&input_line_pointer
, RWARN
| RTYPE_NUM
| RTYPE_GP
, ®
))
17306 mips_frame_reg
= reg
!= 0 ? reg
: SP
;
17307 mips_frame_reg_valid
= 1;
17308 mips_cprestore_valid
= 0;
17314 md_section_align (asection
*seg
, valueT addr
)
17316 int align
= bfd_get_section_alignment (stdoutput
, seg
);
17318 /* We don't need to align ELF sections to the full alignment.
17319 However, Irix 5 may prefer that we align them at least to a 16
17320 byte boundary. We don't bother to align the sections if we
17321 are targeted for an embedded system. */
17322 if (strncmp (TARGET_OS
, "elf", 3) == 0)
17327 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
17330 /* Utility routine, called from above as well. If called while the
17331 input file is still being read, it's only an approximation. (For
17332 example, a symbol may later become defined which appeared to be
17333 undefined earlier.) */
17336 nopic_need_relax (symbolS
*sym
, int before_relaxing
)
17341 if (g_switch_value
> 0)
17343 const char *symname
;
17346 /* Find out whether this symbol can be referenced off the $gp
17347 register. It can be if it is smaller than the -G size or if
17348 it is in the .sdata or .sbss section. Certain symbols can
17349 not be referenced off the $gp, although it appears as though
17351 symname
= S_GET_NAME (sym
);
17352 if (symname
!= (const char *) NULL
17353 && (strcmp (symname
, "eprol") == 0
17354 || strcmp (symname
, "etext") == 0
17355 || strcmp (symname
, "_gp") == 0
17356 || strcmp (symname
, "edata") == 0
17357 || strcmp (symname
, "_fbss") == 0
17358 || strcmp (symname
, "_fdata") == 0
17359 || strcmp (symname
, "_ftext") == 0
17360 || strcmp (symname
, "end") == 0
17361 || strcmp (symname
, "_gp_disp") == 0))
17363 else if ((! S_IS_DEFINED (sym
) || S_IS_COMMON (sym
))
17365 #ifndef NO_ECOFF_DEBUGGING
17366 || (symbol_get_obj (sym
)->ecoff_extern_size
!= 0
17367 && (symbol_get_obj (sym
)->ecoff_extern_size
17368 <= g_switch_value
))
17370 /* We must defer this decision until after the whole
17371 file has been read, since there might be a .extern
17372 after the first use of this symbol. */
17373 || (before_relaxing
17374 #ifndef NO_ECOFF_DEBUGGING
17375 && symbol_get_obj (sym
)->ecoff_extern_size
== 0
17377 && S_GET_VALUE (sym
) == 0)
17378 || (S_GET_VALUE (sym
) != 0
17379 && S_GET_VALUE (sym
) <= g_switch_value
)))
17383 const char *segname
;
17385 segname
= segment_name (S_GET_SEGMENT (sym
));
17386 gas_assert (strcmp (segname
, ".lit8") != 0
17387 && strcmp (segname
, ".lit4") != 0);
17388 change
= (strcmp (segname
, ".sdata") != 0
17389 && strcmp (segname
, ".sbss") != 0
17390 && strncmp (segname
, ".sdata.", 7) != 0
17391 && strncmp (segname
, ".sbss.", 6) != 0
17392 && strncmp (segname
, ".gnu.linkonce.sb.", 17) != 0
17393 && strncmp (segname
, ".gnu.linkonce.s.", 16) != 0);
17398 /* We are not optimizing for the $gp register. */
17403 /* Return true if the given symbol should be considered local for SVR4 PIC. */
17406 pic_need_relax (symbolS
*sym
, asection
*segtype
)
17410 /* Handle the case of a symbol equated to another symbol. */
17411 while (symbol_equated_reloc_p (sym
))
17415 /* It's possible to get a loop here in a badly written program. */
17416 n
= symbol_get_value_expression (sym
)->X_add_symbol
;
17422 if (symbol_section_p (sym
))
17425 symsec
= S_GET_SEGMENT (sym
);
17427 /* This must duplicate the test in adjust_reloc_syms. */
17428 return (!bfd_is_und_section (symsec
)
17429 && !bfd_is_abs_section (symsec
)
17430 && !bfd_is_com_section (symsec
)
17431 && !s_is_linkonce (sym
, segtype
)
17432 /* A global or weak symbol is treated as external. */
17433 && (!S_IS_WEAK (sym
) && !S_IS_EXTERNAL (sym
)));
17437 /* Given a mips16 variant frag FRAGP, return non-zero if it needs an
17438 extended opcode. SEC is the section the frag is in. */
17441 mips16_extended_frag (fragS
*fragp
, asection
*sec
, long stretch
)
17444 const struct mips16_immed_operand
*op
;
17446 int mintiny
, maxtiny
;
17450 if (RELAX_MIPS16_USER_SMALL (fragp
->fr_subtype
))
17452 if (RELAX_MIPS16_USER_EXT (fragp
->fr_subtype
))
17455 type
= RELAX_MIPS16_TYPE (fragp
->fr_subtype
);
17456 op
= mips16_immed_operands
;
17457 while (op
->type
!= type
)
17460 gas_assert (op
< mips16_immed_operands
+ MIPS16_NUM_IMMED
);
17465 if (type
== '<' || type
== '>' || type
== '[' || type
== ']')
17468 maxtiny
= 1 << op
->nbits
;
17473 maxtiny
= (1 << op
->nbits
) - 1;
17478 mintiny
= - (1 << (op
->nbits
- 1));
17479 maxtiny
= (1 << (op
->nbits
- 1)) - 1;
17482 sym_frag
= symbol_get_frag (fragp
->fr_symbol
);
17483 val
= S_GET_VALUE (fragp
->fr_symbol
);
17484 symsec
= S_GET_SEGMENT (fragp
->fr_symbol
);
17490 /* We won't have the section when we are called from
17491 mips_relax_frag. However, we will always have been called
17492 from md_estimate_size_before_relax first. If this is a
17493 branch to a different section, we mark it as such. If SEC is
17494 NULL, and the frag is not marked, then it must be a branch to
17495 the same section. */
17498 if (RELAX_MIPS16_LONG_BRANCH (fragp
->fr_subtype
))
17503 /* Must have been called from md_estimate_size_before_relax. */
17506 fragp
->fr_subtype
=
17507 RELAX_MIPS16_MARK_LONG_BRANCH (fragp
->fr_subtype
);
17509 /* FIXME: We should support this, and let the linker
17510 catch branches and loads that are out of range. */
17511 as_bad_where (fragp
->fr_file
, fragp
->fr_line
,
17512 _("unsupported PC relative reference to different section"));
17516 if (fragp
!= sym_frag
&& sym_frag
->fr_address
== 0)
17517 /* Assume non-extended on the first relaxation pass.
17518 The address we have calculated will be bogus if this is
17519 a forward branch to another frag, as the forward frag
17520 will have fr_address == 0. */
17524 /* In this case, we know for sure that the symbol fragment is in
17525 the same section. If the relax_marker of the symbol fragment
17526 differs from the relax_marker of this fragment, we have not
17527 yet adjusted the symbol fragment fr_address. We want to add
17528 in STRETCH in order to get a better estimate of the address.
17529 This particularly matters because of the shift bits. */
17531 && sym_frag
->relax_marker
!= fragp
->relax_marker
)
17535 /* Adjust stretch for any alignment frag. Note that if have
17536 been expanding the earlier code, the symbol may be
17537 defined in what appears to be an earlier frag. FIXME:
17538 This doesn't handle the fr_subtype field, which specifies
17539 a maximum number of bytes to skip when doing an
17541 for (f
= fragp
; f
!= NULL
&& f
!= sym_frag
; f
= f
->fr_next
)
17543 if (f
->fr_type
== rs_align
|| f
->fr_type
== rs_align_code
)
17546 stretch
= - ((- stretch
)
17547 & ~ ((1 << (int) f
->fr_offset
) - 1));
17549 stretch
&= ~ ((1 << (int) f
->fr_offset
) - 1);
17558 addr
= fragp
->fr_address
+ fragp
->fr_fix
;
17560 /* The base address rules are complicated. The base address of
17561 a branch is the following instruction. The base address of a
17562 PC relative load or add is the instruction itself, but if it
17563 is in a delay slot (in which case it can not be extended) use
17564 the address of the instruction whose delay slot it is in. */
17565 if (type
== 'p' || type
== 'q')
17569 /* If we are currently assuming that this frag should be
17570 extended, then, the current address is two bytes
17572 if (RELAX_MIPS16_EXTENDED (fragp
->fr_subtype
))
17575 /* Ignore the low bit in the target, since it will be set
17576 for a text label. */
17577 if ((val
& 1) != 0)
17580 else if (RELAX_MIPS16_JAL_DSLOT (fragp
->fr_subtype
))
17582 else if (RELAX_MIPS16_DSLOT (fragp
->fr_subtype
))
17585 val
-= addr
& ~ ((1 << op
->shift
) - 1);
17587 /* Branch offsets have an implicit 0 in the lowest bit. */
17588 if (type
== 'p' || type
== 'q')
17591 /* If any of the shifted bits are set, we must use an extended
17592 opcode. If the address depends on the size of this
17593 instruction, this can lead to a loop, so we arrange to always
17594 use an extended opcode. We only check this when we are in
17595 the main relaxation loop, when SEC is NULL. */
17596 if ((val
& ((1 << op
->shift
) - 1)) != 0 && sec
== NULL
)
17598 fragp
->fr_subtype
=
17599 RELAX_MIPS16_MARK_LONG_BRANCH (fragp
->fr_subtype
);
17603 /* If we are about to mark a frag as extended because the value
17604 is precisely maxtiny + 1, then there is a chance of an
17605 infinite loop as in the following code:
17610 In this case when the la is extended, foo is 0x3fc bytes
17611 away, so the la can be shrunk, but then foo is 0x400 away, so
17612 the la must be extended. To avoid this loop, we mark the
17613 frag as extended if it was small, and is about to become
17614 extended with a value of maxtiny + 1. */
17615 if (val
== ((maxtiny
+ 1) << op
->shift
)
17616 && ! RELAX_MIPS16_EXTENDED (fragp
->fr_subtype
)
17619 fragp
->fr_subtype
=
17620 RELAX_MIPS16_MARK_LONG_BRANCH (fragp
->fr_subtype
);
17624 else if (symsec
!= absolute_section
&& sec
!= NULL
)
17625 as_bad_where (fragp
->fr_file
, fragp
->fr_line
, _("unsupported relocation"));
17627 if ((val
& ((1 << op
->shift
) - 1)) != 0
17628 || val
< (mintiny
<< op
->shift
)
17629 || val
> (maxtiny
<< op
->shift
))
17635 /* Compute the length of a branch sequence, and adjust the
17636 RELAX_BRANCH_TOOFAR bit accordingly. If FRAGP is NULL, the
17637 worst-case length is computed, with UPDATE being used to indicate
17638 whether an unconditional (-1), branch-likely (+1) or regular (0)
17639 branch is to be computed. */
17641 relaxed_branch_length (fragS
*fragp
, asection
*sec
, int update
)
17643 bfd_boolean toofar
;
17647 && S_IS_DEFINED (fragp
->fr_symbol
)
17648 && sec
== S_GET_SEGMENT (fragp
->fr_symbol
))
17653 val
= S_GET_VALUE (fragp
->fr_symbol
) + fragp
->fr_offset
;
17655 addr
= fragp
->fr_address
+ fragp
->fr_fix
+ 4;
17659 toofar
= val
< - (0x8000 << 2) || val
>= (0x8000 << 2);
17662 /* If the symbol is not defined or it's in a different segment,
17663 assume the user knows what's going on and emit a short
17669 if (fragp
&& update
&& toofar
!= RELAX_BRANCH_TOOFAR (fragp
->fr_subtype
))
17671 = RELAX_BRANCH_ENCODE (RELAX_BRANCH_AT (fragp
->fr_subtype
),
17672 RELAX_BRANCH_UNCOND (fragp
->fr_subtype
),
17673 RELAX_BRANCH_LIKELY (fragp
->fr_subtype
),
17674 RELAX_BRANCH_LINK (fragp
->fr_subtype
),
17680 if (fragp
? RELAX_BRANCH_LIKELY (fragp
->fr_subtype
) : (update
> 0))
17683 if (mips_pic
!= NO_PIC
)
17685 /* Additional space for PIC loading of target address. */
17687 if (mips_opts
.isa
== ISA_MIPS1
)
17688 /* Additional space for $at-stabilizing nop. */
17692 /* If branch is conditional. */
17693 if (fragp
? !RELAX_BRANCH_UNCOND (fragp
->fr_subtype
) : (update
>= 0))
17700 /* Compute the length of a branch sequence, and adjust the
17701 RELAX_MICROMIPS_TOOFAR32 bit accordingly. If FRAGP is NULL, the
17702 worst-case length is computed, with UPDATE being used to indicate
17703 whether an unconditional (-1), or regular (0) branch is to be
17707 relaxed_micromips_32bit_branch_length (fragS
*fragp
, asection
*sec
, int update
)
17709 bfd_boolean toofar
;
17713 && S_IS_DEFINED (fragp
->fr_symbol
)
17714 && sec
== S_GET_SEGMENT (fragp
->fr_symbol
))
17719 val
= S_GET_VALUE (fragp
->fr_symbol
) + fragp
->fr_offset
;
17720 /* Ignore the low bit in the target, since it will be set
17721 for a text label. */
17722 if ((val
& 1) != 0)
17725 addr
= fragp
->fr_address
+ fragp
->fr_fix
+ 4;
17729 toofar
= val
< - (0x8000 << 1) || val
>= (0x8000 << 1);
17732 /* If the symbol is not defined or it's in a different segment,
17733 assume the user knows what's going on and emit a short
17739 if (fragp
&& update
17740 && toofar
!= RELAX_MICROMIPS_TOOFAR32 (fragp
->fr_subtype
))
17741 fragp
->fr_subtype
= (toofar
17742 ? RELAX_MICROMIPS_MARK_TOOFAR32 (fragp
->fr_subtype
)
17743 : RELAX_MICROMIPS_CLEAR_TOOFAR32 (fragp
->fr_subtype
));
17748 bfd_boolean compact_known
= fragp
!= NULL
;
17749 bfd_boolean compact
= FALSE
;
17750 bfd_boolean uncond
;
17753 compact
= RELAX_MICROMIPS_COMPACT (fragp
->fr_subtype
);
17755 uncond
= RELAX_MICROMIPS_UNCOND (fragp
->fr_subtype
);
17757 uncond
= update
< 0;
17759 /* If label is out of range, we turn branch <br>:
17761 <br> label # 4 bytes
17767 nop # 2 bytes if compact && !PIC
17770 if (mips_pic
== NO_PIC
&& (!compact_known
|| compact
))
17773 /* If assembling PIC code, we further turn:
17779 lw/ld at, %got(label)(gp) # 4 bytes
17780 d/addiu at, %lo(label) # 4 bytes
17783 if (mips_pic
!= NO_PIC
)
17786 /* If branch <br> is conditional, we prepend negated branch <brneg>:
17788 <brneg> 0f # 4 bytes
17789 nop # 2 bytes if !compact
17792 length
+= (compact_known
&& compact
) ? 4 : 6;
17798 /* Compute the length of a branch, and adjust the RELAX_MICROMIPS_TOOFAR16
17799 bit accordingly. */
17802 relaxed_micromips_16bit_branch_length (fragS
*fragp
, asection
*sec
, int update
)
17804 bfd_boolean toofar
;
17807 && S_IS_DEFINED (fragp
->fr_symbol
)
17808 && sec
== S_GET_SEGMENT (fragp
->fr_symbol
))
17814 val
= S_GET_VALUE (fragp
->fr_symbol
) + fragp
->fr_offset
;
17815 /* Ignore the low bit in the target, since it will be set
17816 for a text label. */
17817 if ((val
& 1) != 0)
17820 /* Assume this is a 2-byte branch. */
17821 addr
= fragp
->fr_address
+ fragp
->fr_fix
+ 2;
17823 /* We try to avoid the infinite loop by not adding 2 more bytes for
17828 type
= RELAX_MICROMIPS_TYPE (fragp
->fr_subtype
);
17830 toofar
= val
< - (0x200 << 1) || val
>= (0x200 << 1);
17831 else if (type
== 'E')
17832 toofar
= val
< - (0x40 << 1) || val
>= (0x40 << 1);
17837 /* If the symbol is not defined or it's in a different segment,
17838 we emit a normal 32-bit branch. */
17841 if (fragp
&& update
17842 && toofar
!= RELAX_MICROMIPS_TOOFAR16 (fragp
->fr_subtype
))
17844 = toofar
? RELAX_MICROMIPS_MARK_TOOFAR16 (fragp
->fr_subtype
)
17845 : RELAX_MICROMIPS_CLEAR_TOOFAR16 (fragp
->fr_subtype
);
17853 /* Estimate the size of a frag before relaxing. Unless this is the
17854 mips16, we are not really relaxing here, and the final size is
17855 encoded in the subtype information. For the mips16, we have to
17856 decide whether we are using an extended opcode or not. */
17859 md_estimate_size_before_relax (fragS
*fragp
, asection
*segtype
)
17863 if (RELAX_BRANCH_P (fragp
->fr_subtype
))
17866 fragp
->fr_var
= relaxed_branch_length (fragp
, segtype
, FALSE
);
17868 return fragp
->fr_var
;
17871 if (RELAX_MIPS16_P (fragp
->fr_subtype
))
17872 /* We don't want to modify the EXTENDED bit here; it might get us
17873 into infinite loops. We change it only in mips_relax_frag(). */
17874 return (RELAX_MIPS16_EXTENDED (fragp
->fr_subtype
) ? 4 : 2);
17876 if (RELAX_MICROMIPS_P (fragp
->fr_subtype
))
17880 if (RELAX_MICROMIPS_TYPE (fragp
->fr_subtype
) != 0)
17881 length
= relaxed_micromips_16bit_branch_length (fragp
, segtype
, FALSE
);
17882 if (length
== 4 && RELAX_MICROMIPS_RELAX32 (fragp
->fr_subtype
))
17883 length
= relaxed_micromips_32bit_branch_length (fragp
, segtype
, FALSE
);
17884 fragp
->fr_var
= length
;
17889 if (mips_pic
== NO_PIC
)
17890 change
= nopic_need_relax (fragp
->fr_symbol
, 0);
17891 else if (mips_pic
== SVR4_PIC
)
17892 change
= pic_need_relax (fragp
->fr_symbol
, segtype
);
17893 else if (mips_pic
== VXWORKS_PIC
)
17894 /* For vxworks, GOT16 relocations never have a corresponding LO16. */
17901 fragp
->fr_subtype
|= RELAX_USE_SECOND
;
17902 return -RELAX_FIRST (fragp
->fr_subtype
);
17905 return -RELAX_SECOND (fragp
->fr_subtype
);
17908 /* This is called to see whether a reloc against a defined symbol
17909 should be converted into a reloc against a section. */
17912 mips_fix_adjustable (fixS
*fixp
)
17914 if (fixp
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
17915 || fixp
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
17918 if (fixp
->fx_addsy
== NULL
)
17921 /* If symbol SYM is in a mergeable section, relocations of the form
17922 SYM + 0 can usually be made section-relative. The mergeable data
17923 is then identified by the section offset rather than by the symbol.
17925 However, if we're generating REL LO16 relocations, the offset is split
17926 between the LO16 and parterning high part relocation. The linker will
17927 need to recalculate the complete offset in order to correctly identify
17930 The linker has traditionally not looked for the parterning high part
17931 relocation, and has thus allowed orphaned R_MIPS_LO16 relocations to be
17932 placed anywhere. Rather than break backwards compatibility by changing
17933 this, it seems better not to force the issue, and instead keep the
17934 original symbol. This will work with either linker behavior. */
17935 if ((lo16_reloc_p (fixp
->fx_r_type
)
17936 || reloc_needs_lo_p (fixp
->fx_r_type
))
17937 && HAVE_IN_PLACE_ADDENDS
17938 && (S_GET_SEGMENT (fixp
->fx_addsy
)->flags
& SEC_MERGE
) != 0)
17941 /* There is no place to store an in-place offset for JALR relocations.
17942 Likewise an in-range offset of limited PC-relative relocations may
17943 overflow the in-place relocatable field if recalculated against the
17944 start address of the symbol's containing section. */
17945 if (HAVE_IN_PLACE_ADDENDS
17946 && (limited_pcrel_reloc_p (fixp
->fx_r_type
)
17947 || jalr_reloc_p (fixp
->fx_r_type
)))
17950 /* R_MIPS16_26 relocations against non-MIPS16 functions might resolve
17951 to a floating-point stub. The same is true for non-R_MIPS16_26
17952 relocations against MIPS16 functions; in this case, the stub becomes
17953 the function's canonical address.
17955 Floating-point stubs are stored in unique .mips16.call.* or
17956 .mips16.fn.* sections. If a stub T for function F is in section S,
17957 the first relocation in section S must be against F; this is how the
17958 linker determines the target function. All relocations that might
17959 resolve to T must also be against F. We therefore have the following
17960 restrictions, which are given in an intentionally-redundant way:
17962 1. We cannot reduce R_MIPS16_26 relocations against non-MIPS16
17965 2. We cannot reduce a stub's relocations against non-MIPS16 symbols
17966 if that stub might be used.
17968 3. We cannot reduce non-R_MIPS16_26 relocations against MIPS16
17971 4. We cannot reduce a stub's relocations against MIPS16 symbols if
17972 that stub might be used.
17974 There is a further restriction:
17976 5. We cannot reduce jump relocations (R_MIPS_26, R_MIPS16_26 or
17977 R_MICROMIPS_26_S1) against MIPS16 or microMIPS symbols on
17978 targets with in-place addends; the relocation field cannot
17979 encode the low bit.
17981 For simplicity, we deal with (3)-(4) by not reducing _any_ relocation
17982 against a MIPS16 symbol. We deal with (5) by by not reducing any
17983 such relocations on REL targets.
17985 We deal with (1)-(2) by saying that, if there's a R_MIPS16_26
17986 relocation against some symbol R, no relocation against R may be
17987 reduced. (Note that this deals with (2) as well as (1) because
17988 relocations against global symbols will never be reduced on ELF
17989 targets.) This approach is a little simpler than trying to detect
17990 stub sections, and gives the "all or nothing" per-symbol consistency
17991 that we have for MIPS16 symbols. */
17992 if (fixp
->fx_subsy
== NULL
17993 && (ELF_ST_IS_MIPS16 (S_GET_OTHER (fixp
->fx_addsy
))
17994 || *symbol_get_tc (fixp
->fx_addsy
)
17995 || (HAVE_IN_PLACE_ADDENDS
17996 && ELF_ST_IS_MICROMIPS (S_GET_OTHER (fixp
->fx_addsy
))
17997 && jmp_reloc_p (fixp
->fx_r_type
))))
18003 /* Translate internal representation of relocation info to BFD target
18007 tc_gen_reloc (asection
*section ATTRIBUTE_UNUSED
, fixS
*fixp
)
18009 static arelent
*retval
[4];
18011 bfd_reloc_code_real_type code
;
18013 memset (retval
, 0, sizeof(retval
));
18014 reloc
= retval
[0] = (arelent
*) xcalloc (1, sizeof (arelent
));
18015 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
18016 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
18017 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
18019 if (fixp
->fx_pcrel
)
18021 gas_assert (fixp
->fx_r_type
== BFD_RELOC_16_PCREL_S2
18022 || fixp
->fx_r_type
== BFD_RELOC_MICROMIPS_7_PCREL_S1
18023 || fixp
->fx_r_type
== BFD_RELOC_MICROMIPS_10_PCREL_S1
18024 || fixp
->fx_r_type
== BFD_RELOC_MICROMIPS_16_PCREL_S1
18025 || fixp
->fx_r_type
== BFD_RELOC_32_PCREL
);
18027 /* At this point, fx_addnumber is "symbol offset - pcrel address".
18028 Relocations want only the symbol offset. */
18029 reloc
->addend
= fixp
->fx_addnumber
+ reloc
->address
;
18032 reloc
->addend
= fixp
->fx_addnumber
;
18034 /* Since the old MIPS ELF ABI uses Rel instead of Rela, encode the vtable
18035 entry to be used in the relocation's section offset. */
18036 if (! HAVE_NEWABI
&& fixp
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
18038 reloc
->address
= reloc
->addend
;
18042 code
= fixp
->fx_r_type
;
18044 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
18045 if (reloc
->howto
== NULL
)
18047 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
18048 _("Can not represent %s relocation in this object file format"),
18049 bfd_get_reloc_code_name (code
));
18056 /* Relax a machine dependent frag. This returns the amount by which
18057 the current size of the frag should change. */
18060 mips_relax_frag (asection
*sec
, fragS
*fragp
, long stretch
)
18062 if (RELAX_BRANCH_P (fragp
->fr_subtype
))
18064 offsetT old_var
= fragp
->fr_var
;
18066 fragp
->fr_var
= relaxed_branch_length (fragp
, sec
, TRUE
);
18068 return fragp
->fr_var
- old_var
;
18071 if (RELAX_MICROMIPS_P (fragp
->fr_subtype
))
18073 offsetT old_var
= fragp
->fr_var
;
18074 offsetT new_var
= 4;
18076 if (RELAX_MICROMIPS_TYPE (fragp
->fr_subtype
) != 0)
18077 new_var
= relaxed_micromips_16bit_branch_length (fragp
, sec
, TRUE
);
18078 if (new_var
== 4 && RELAX_MICROMIPS_RELAX32 (fragp
->fr_subtype
))
18079 new_var
= relaxed_micromips_32bit_branch_length (fragp
, sec
, TRUE
);
18080 fragp
->fr_var
= new_var
;
18082 return new_var
- old_var
;
18085 if (! RELAX_MIPS16_P (fragp
->fr_subtype
))
18088 if (mips16_extended_frag (fragp
, NULL
, stretch
))
18090 if (RELAX_MIPS16_EXTENDED (fragp
->fr_subtype
))
18092 fragp
->fr_subtype
= RELAX_MIPS16_MARK_EXTENDED (fragp
->fr_subtype
);
18097 if (! RELAX_MIPS16_EXTENDED (fragp
->fr_subtype
))
18099 fragp
->fr_subtype
= RELAX_MIPS16_CLEAR_EXTENDED (fragp
->fr_subtype
);
18106 /* Convert a machine dependent frag. */
18109 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
, segT asec
, fragS
*fragp
)
18111 if (RELAX_BRANCH_P (fragp
->fr_subtype
))
18114 unsigned long insn
;
18118 buf
= fragp
->fr_literal
+ fragp
->fr_fix
;
18119 insn
= read_insn (buf
);
18121 if (!RELAX_BRANCH_TOOFAR (fragp
->fr_subtype
))
18123 /* We generate a fixup instead of applying it right now
18124 because, if there are linker relaxations, we're going to
18125 need the relocations. */
18126 exp
.X_op
= O_symbol
;
18127 exp
.X_add_symbol
= fragp
->fr_symbol
;
18128 exp
.X_add_number
= fragp
->fr_offset
;
18130 fixp
= fix_new_exp (fragp
, buf
- fragp
->fr_literal
, 4, &exp
, TRUE
,
18131 BFD_RELOC_16_PCREL_S2
);
18132 fixp
->fx_file
= fragp
->fr_file
;
18133 fixp
->fx_line
= fragp
->fr_line
;
18135 buf
= write_insn (buf
, insn
);
18141 as_warn_where (fragp
->fr_file
, fragp
->fr_line
,
18142 _("Relaxed out-of-range branch into a jump"));
18144 if (RELAX_BRANCH_UNCOND (fragp
->fr_subtype
))
18147 if (!RELAX_BRANCH_LIKELY (fragp
->fr_subtype
))
18149 /* Reverse the branch. */
18150 switch ((insn
>> 28) & 0xf)
18153 /* bc[0-3][tf]l? instructions can have the condition
18154 reversed by tweaking a single TF bit, and their
18155 opcodes all have 0x4???????. */
18156 gas_assert ((insn
& 0xf3e00000) == 0x41000000);
18157 insn
^= 0x00010000;
18161 /* bltz 0x04000000 bgez 0x04010000
18162 bltzal 0x04100000 bgezal 0x04110000 */
18163 gas_assert ((insn
& 0xfc0e0000) == 0x04000000);
18164 insn
^= 0x00010000;
18168 /* beq 0x10000000 bne 0x14000000
18169 blez 0x18000000 bgtz 0x1c000000 */
18170 insn
^= 0x04000000;
18178 if (RELAX_BRANCH_LINK (fragp
->fr_subtype
))
18180 /* Clear the and-link bit. */
18181 gas_assert ((insn
& 0xfc1c0000) == 0x04100000);
18183 /* bltzal 0x04100000 bgezal 0x04110000
18184 bltzall 0x04120000 bgezall 0x04130000 */
18185 insn
&= ~0x00100000;
18188 /* Branch over the branch (if the branch was likely) or the
18189 full jump (not likely case). Compute the offset from the
18190 current instruction to branch to. */
18191 if (RELAX_BRANCH_LIKELY (fragp
->fr_subtype
))
18195 /* How many bytes in instructions we've already emitted? */
18196 i
= buf
- fragp
->fr_literal
- fragp
->fr_fix
;
18197 /* How many bytes in instructions from here to the end? */
18198 i
= fragp
->fr_var
- i
;
18200 /* Convert to instruction count. */
18202 /* Branch counts from the next instruction. */
18205 /* Branch over the jump. */
18206 buf
= write_insn (buf
, insn
);
18209 buf
= write_insn (buf
, 0);
18211 if (RELAX_BRANCH_LIKELY (fragp
->fr_subtype
))
18213 /* beql $0, $0, 2f */
18215 /* Compute the PC offset from the current instruction to
18216 the end of the variable frag. */
18217 /* How many bytes in instructions we've already emitted? */
18218 i
= buf
- fragp
->fr_literal
- fragp
->fr_fix
;
18219 /* How many bytes in instructions from here to the end? */
18220 i
= fragp
->fr_var
- i
;
18221 /* Convert to instruction count. */
18223 /* Don't decrement i, because we want to branch over the
18227 buf
= write_insn (buf
, insn
);
18228 buf
= write_insn (buf
, 0);
18232 if (mips_pic
== NO_PIC
)
18235 insn
= (RELAX_BRANCH_LINK (fragp
->fr_subtype
)
18236 ? 0x0c000000 : 0x08000000);
18237 exp
.X_op
= O_symbol
;
18238 exp
.X_add_symbol
= fragp
->fr_symbol
;
18239 exp
.X_add_number
= fragp
->fr_offset
;
18241 fixp
= fix_new_exp (fragp
, buf
- fragp
->fr_literal
, 4, &exp
,
18242 FALSE
, BFD_RELOC_MIPS_JMP
);
18243 fixp
->fx_file
= fragp
->fr_file
;
18244 fixp
->fx_line
= fragp
->fr_line
;
18246 buf
= write_insn (buf
, insn
);
18250 unsigned long at
= RELAX_BRANCH_AT (fragp
->fr_subtype
);
18252 /* lw/ld $at, <sym>($gp) R_MIPS_GOT16 */
18253 insn
= HAVE_64BIT_ADDRESSES
? 0xdf800000 : 0x8f800000;
18254 insn
|= at
<< OP_SH_RT
;
18255 exp
.X_op
= O_symbol
;
18256 exp
.X_add_symbol
= fragp
->fr_symbol
;
18257 exp
.X_add_number
= fragp
->fr_offset
;
18259 if (fragp
->fr_offset
)
18261 exp
.X_add_symbol
= make_expr_symbol (&exp
);
18262 exp
.X_add_number
= 0;
18265 fixp
= fix_new_exp (fragp
, buf
- fragp
->fr_literal
, 4, &exp
,
18266 FALSE
, BFD_RELOC_MIPS_GOT16
);
18267 fixp
->fx_file
= fragp
->fr_file
;
18268 fixp
->fx_line
= fragp
->fr_line
;
18270 buf
= write_insn (buf
, insn
);
18272 if (mips_opts
.isa
== ISA_MIPS1
)
18274 buf
= write_insn (buf
, 0);
18276 /* d/addiu $at, $at, <sym> R_MIPS_LO16 */
18277 insn
= HAVE_64BIT_ADDRESSES
? 0x64000000 : 0x24000000;
18278 insn
|= at
<< OP_SH_RS
| at
<< OP_SH_RT
;
18280 fixp
= fix_new_exp (fragp
, buf
- fragp
->fr_literal
, 4, &exp
,
18281 FALSE
, BFD_RELOC_LO16
);
18282 fixp
->fx_file
= fragp
->fr_file
;
18283 fixp
->fx_line
= fragp
->fr_line
;
18285 buf
= write_insn (buf
, insn
);
18288 if (RELAX_BRANCH_LINK (fragp
->fr_subtype
))
18292 insn
|= at
<< OP_SH_RS
;
18294 buf
= write_insn (buf
, insn
);
18298 fragp
->fr_fix
+= fragp
->fr_var
;
18299 gas_assert (buf
== fragp
->fr_literal
+ fragp
->fr_fix
);
18303 /* Relax microMIPS branches. */
18304 if (RELAX_MICROMIPS_P (fragp
->fr_subtype
))
18306 char *buf
= fragp
->fr_literal
+ fragp
->fr_fix
;
18307 bfd_boolean compact
= RELAX_MICROMIPS_COMPACT (fragp
->fr_subtype
);
18308 bfd_boolean al
= RELAX_MICROMIPS_LINK (fragp
->fr_subtype
);
18309 int type
= RELAX_MICROMIPS_TYPE (fragp
->fr_subtype
);
18310 bfd_boolean short_ds
;
18311 unsigned long insn
;
18315 exp
.X_op
= O_symbol
;
18316 exp
.X_add_symbol
= fragp
->fr_symbol
;
18317 exp
.X_add_number
= fragp
->fr_offset
;
18319 fragp
->fr_fix
+= fragp
->fr_var
;
18321 /* Handle 16-bit branches that fit or are forced to fit. */
18322 if (type
!= 0 && !RELAX_MICROMIPS_TOOFAR16 (fragp
->fr_subtype
))
18324 /* We generate a fixup instead of applying it right now,
18325 because if there is linker relaxation, we're going to
18326 need the relocations. */
18328 fixp
= fix_new_exp (fragp
, buf
- fragp
->fr_literal
, 2, &exp
, TRUE
,
18329 BFD_RELOC_MICROMIPS_10_PCREL_S1
);
18330 else if (type
== 'E')
18331 fixp
= fix_new_exp (fragp
, buf
- fragp
->fr_literal
, 2, &exp
, TRUE
,
18332 BFD_RELOC_MICROMIPS_7_PCREL_S1
);
18336 fixp
->fx_file
= fragp
->fr_file
;
18337 fixp
->fx_line
= fragp
->fr_line
;
18339 /* These relocations can have an addend that won't fit in
18341 fixp
->fx_no_overflow
= 1;
18346 /* Handle 32-bit branches that fit or are forced to fit. */
18347 if (!RELAX_MICROMIPS_RELAX32 (fragp
->fr_subtype
)
18348 || !RELAX_MICROMIPS_TOOFAR32 (fragp
->fr_subtype
))
18350 /* We generate a fixup instead of applying it right now,
18351 because if there is linker relaxation, we're going to
18352 need the relocations. */
18353 fixp
= fix_new_exp (fragp
, buf
- fragp
->fr_literal
, 4, &exp
, TRUE
,
18354 BFD_RELOC_MICROMIPS_16_PCREL_S1
);
18355 fixp
->fx_file
= fragp
->fr_file
;
18356 fixp
->fx_line
= fragp
->fr_line
;
18362 /* Relax 16-bit branches to 32-bit branches. */
18365 insn
= read_compressed_insn (buf
, 2);
18367 if ((insn
& 0xfc00) == 0xcc00) /* b16 */
18368 insn
= 0x94000000; /* beq */
18369 else if ((insn
& 0xdc00) == 0x8c00) /* beqz16/bnez16 */
18371 unsigned long regno
;
18373 regno
= (insn
>> MICROMIPSOP_SH_MD
) & MICROMIPSOP_MASK_MD
;
18374 regno
= micromips_to_32_reg_d_map
[regno
];
18375 insn
= ((insn
& 0x2000) << 16) | 0x94000000; /* beq/bne */
18376 insn
|= regno
<< MICROMIPSOP_SH_RS
;
18381 /* Nothing else to do, just write it out. */
18382 if (!RELAX_MICROMIPS_RELAX32 (fragp
->fr_subtype
)
18383 || !RELAX_MICROMIPS_TOOFAR32 (fragp
->fr_subtype
))
18385 buf
= write_compressed_insn (buf
, insn
, 4);
18386 gas_assert (buf
== fragp
->fr_literal
+ fragp
->fr_fix
);
18391 insn
= read_compressed_insn (buf
, 4);
18393 /* Relax 32-bit branches to a sequence of instructions. */
18394 as_warn_where (fragp
->fr_file
, fragp
->fr_line
,
18395 _("Relaxed out-of-range branch into a jump"));
18397 /* Set the short-delay-slot bit. */
18398 short_ds
= al
&& (insn
& 0x02000000) != 0;
18400 if (!RELAX_MICROMIPS_UNCOND (fragp
->fr_subtype
))
18404 /* Reverse the branch. */
18405 if ((insn
& 0xfc000000) == 0x94000000 /* beq */
18406 || (insn
& 0xfc000000) == 0xb4000000) /* bne */
18407 insn
^= 0x20000000;
18408 else if ((insn
& 0xffe00000) == 0x40000000 /* bltz */
18409 || (insn
& 0xffe00000) == 0x40400000 /* bgez */
18410 || (insn
& 0xffe00000) == 0x40800000 /* blez */
18411 || (insn
& 0xffe00000) == 0x40c00000 /* bgtz */
18412 || (insn
& 0xffe00000) == 0x40a00000 /* bnezc */
18413 || (insn
& 0xffe00000) == 0x40e00000 /* beqzc */
18414 || (insn
& 0xffe00000) == 0x40200000 /* bltzal */
18415 || (insn
& 0xffe00000) == 0x40600000 /* bgezal */
18416 || (insn
& 0xffe00000) == 0x42200000 /* bltzals */
18417 || (insn
& 0xffe00000) == 0x42600000) /* bgezals */
18418 insn
^= 0x00400000;
18419 else if ((insn
& 0xffe30000) == 0x43800000 /* bc1f */
18420 || (insn
& 0xffe30000) == 0x43a00000 /* bc1t */
18421 || (insn
& 0xffe30000) == 0x42800000 /* bc2f */
18422 || (insn
& 0xffe30000) == 0x42a00000) /* bc2t */
18423 insn
^= 0x00200000;
18429 /* Clear the and-link and short-delay-slot bits. */
18430 gas_assert ((insn
& 0xfda00000) == 0x40200000);
18432 /* bltzal 0x40200000 bgezal 0x40600000 */
18433 /* bltzals 0x42200000 bgezals 0x42600000 */
18434 insn
&= ~0x02200000;
18437 /* Make a label at the end for use with the branch. */
18438 l
= symbol_new (micromips_label_name (), asec
, fragp
->fr_fix
, fragp
);
18439 micromips_label_inc ();
18440 S_SET_OTHER (l
, ELF_ST_SET_MICROMIPS (S_GET_OTHER (l
)));
18443 fixp
= fix_new (fragp
, buf
- fragp
->fr_literal
, 4, l
, 0, TRUE
,
18444 BFD_RELOC_MICROMIPS_16_PCREL_S1
);
18445 fixp
->fx_file
= fragp
->fr_file
;
18446 fixp
->fx_line
= fragp
->fr_line
;
18448 /* Branch over the jump. */
18449 buf
= write_compressed_insn (buf
, insn
, 4);
18452 buf
= write_compressed_insn (buf
, 0x0c00, 2);
18455 if (mips_pic
== NO_PIC
)
18457 unsigned long jal
= short_ds
? 0x74000000 : 0xf4000000; /* jal/s */
18459 /* j/jal/jals <sym> R_MICROMIPS_26_S1 */
18460 insn
= al
? jal
: 0xd4000000;
18462 fixp
= fix_new_exp (fragp
, buf
- fragp
->fr_literal
, 4, &exp
, FALSE
,
18463 BFD_RELOC_MICROMIPS_JMP
);
18464 fixp
->fx_file
= fragp
->fr_file
;
18465 fixp
->fx_line
= fragp
->fr_line
;
18467 buf
= write_compressed_insn (buf
, insn
, 4);
18470 buf
= write_compressed_insn (buf
, 0x0c00, 2);
18474 unsigned long at
= RELAX_MICROMIPS_AT (fragp
->fr_subtype
);
18475 unsigned long jalr
= short_ds
? 0x45e0 : 0x45c0; /* jalr/s */
18476 unsigned long jr
= compact
? 0x45a0 : 0x4580; /* jr/c */
18478 /* lw/ld $at, <sym>($gp) R_MICROMIPS_GOT16 */
18479 insn
= HAVE_64BIT_ADDRESSES
? 0xdc1c0000 : 0xfc1c0000;
18480 insn
|= at
<< MICROMIPSOP_SH_RT
;
18482 if (exp
.X_add_number
)
18484 exp
.X_add_symbol
= make_expr_symbol (&exp
);
18485 exp
.X_add_number
= 0;
18488 fixp
= fix_new_exp (fragp
, buf
- fragp
->fr_literal
, 4, &exp
, FALSE
,
18489 BFD_RELOC_MICROMIPS_GOT16
);
18490 fixp
->fx_file
= fragp
->fr_file
;
18491 fixp
->fx_line
= fragp
->fr_line
;
18493 buf
= write_compressed_insn (buf
, insn
, 4);
18495 /* d/addiu $at, $at, <sym> R_MICROMIPS_LO16 */
18496 insn
= HAVE_64BIT_ADDRESSES
? 0x5c000000 : 0x30000000;
18497 insn
|= at
<< MICROMIPSOP_SH_RT
| at
<< MICROMIPSOP_SH_RS
;
18499 fixp
= fix_new_exp (fragp
, buf
- fragp
->fr_literal
, 4, &exp
, FALSE
,
18500 BFD_RELOC_MICROMIPS_LO16
);
18501 fixp
->fx_file
= fragp
->fr_file
;
18502 fixp
->fx_line
= fragp
->fr_line
;
18504 buf
= write_compressed_insn (buf
, insn
, 4);
18506 /* jr/jrc/jalr/jalrs $at */
18507 insn
= al
? jalr
: jr
;
18508 insn
|= at
<< MICROMIPSOP_SH_MJ
;
18510 buf
= write_compressed_insn (buf
, insn
, 2);
18513 gas_assert (buf
== fragp
->fr_literal
+ fragp
->fr_fix
);
18517 if (RELAX_MIPS16_P (fragp
->fr_subtype
))
18520 const struct mips16_immed_operand
*op
;
18523 unsigned int user_length
, length
;
18524 unsigned long insn
;
18527 type
= RELAX_MIPS16_TYPE (fragp
->fr_subtype
);
18528 op
= mips16_immed_operands
;
18529 while (op
->type
!= type
)
18532 ext
= RELAX_MIPS16_EXTENDED (fragp
->fr_subtype
);
18533 val
= resolve_symbol_value (fragp
->fr_symbol
);
18538 addr
= fragp
->fr_address
+ fragp
->fr_fix
;
18540 /* The rules for the base address of a PC relative reloc are
18541 complicated; see mips16_extended_frag. */
18542 if (type
== 'p' || type
== 'q')
18547 /* Ignore the low bit in the target, since it will be
18548 set for a text label. */
18549 if ((val
& 1) != 0)
18552 else if (RELAX_MIPS16_JAL_DSLOT (fragp
->fr_subtype
))
18554 else if (RELAX_MIPS16_DSLOT (fragp
->fr_subtype
))
18557 addr
&= ~ (addressT
) ((1 << op
->shift
) - 1);
18560 /* Make sure the section winds up with the alignment we have
18563 record_alignment (asec
, op
->shift
);
18567 && (RELAX_MIPS16_JAL_DSLOT (fragp
->fr_subtype
)
18568 || RELAX_MIPS16_DSLOT (fragp
->fr_subtype
)))
18569 as_warn_where (fragp
->fr_file
, fragp
->fr_line
,
18570 _("extended instruction in delay slot"));
18572 buf
= fragp
->fr_literal
+ fragp
->fr_fix
;
18574 insn
= read_compressed_insn (buf
, 2);
18576 insn
|= MIPS16_EXTEND
;
18578 if (RELAX_MIPS16_USER_EXT (fragp
->fr_subtype
))
18580 else if (RELAX_MIPS16_USER_SMALL (fragp
->fr_subtype
))
18585 mips16_immed (fragp
->fr_file
, fragp
->fr_line
, type
,
18586 BFD_RELOC_UNUSED
, val
, user_length
, &insn
);
18588 length
= (ext
? 4 : 2);
18589 gas_assert (mips16_opcode_length (insn
) == length
);
18590 write_compressed_insn (buf
, insn
, length
);
18591 fragp
->fr_fix
+= length
;
18595 relax_substateT subtype
= fragp
->fr_subtype
;
18596 bfd_boolean second_longer
= (subtype
& RELAX_SECOND_LONGER
) != 0;
18597 bfd_boolean use_second
= (subtype
& RELAX_USE_SECOND
) != 0;
18601 first
= RELAX_FIRST (subtype
);
18602 second
= RELAX_SECOND (subtype
);
18603 fixp
= (fixS
*) fragp
->fr_opcode
;
18605 /* If the delay slot chosen does not match the size of the instruction,
18606 then emit a warning. */
18607 if ((!use_second
&& (subtype
& RELAX_DELAY_SLOT_SIZE_FIRST
) != 0)
18608 || (use_second
&& (subtype
& RELAX_DELAY_SLOT_SIZE_SECOND
) != 0))
18613 s
= subtype
& (RELAX_DELAY_SLOT_16BIT
18614 | RELAX_DELAY_SLOT_SIZE_FIRST
18615 | RELAX_DELAY_SLOT_SIZE_SECOND
);
18616 msg
= macro_warning (s
);
18618 as_warn_where (fragp
->fr_file
, fragp
->fr_line
, "%s", msg
);
18622 /* Possibly emit a warning if we've chosen the longer option. */
18623 if (use_second
== second_longer
)
18629 & (RELAX_SECOND_LONGER
| RELAX_NOMACRO
| RELAX_DELAY_SLOT
));
18630 msg
= macro_warning (s
);
18632 as_warn_where (fragp
->fr_file
, fragp
->fr_line
, "%s", msg
);
18636 /* Go through all the fixups for the first sequence. Disable them
18637 (by marking them as done) if we're going to use the second
18638 sequence instead. */
18640 && fixp
->fx_frag
== fragp
18641 && fixp
->fx_where
< fragp
->fr_fix
- second
)
18643 if (subtype
& RELAX_USE_SECOND
)
18645 fixp
= fixp
->fx_next
;
18648 /* Go through the fixups for the second sequence. Disable them if
18649 we're going to use the first sequence, otherwise adjust their
18650 addresses to account for the relaxation. */
18651 while (fixp
&& fixp
->fx_frag
== fragp
)
18653 if (subtype
& RELAX_USE_SECOND
)
18654 fixp
->fx_where
-= first
;
18657 fixp
= fixp
->fx_next
;
18660 /* Now modify the frag contents. */
18661 if (subtype
& RELAX_USE_SECOND
)
18665 start
= fragp
->fr_literal
+ fragp
->fr_fix
- first
- second
;
18666 memmove (start
, start
+ first
, second
);
18667 fragp
->fr_fix
-= first
;
18670 fragp
->fr_fix
-= second
;
18674 /* This function is called after the relocs have been generated.
18675 We've been storing mips16 text labels as odd. Here we convert them
18676 back to even for the convenience of the debugger. */
18679 mips_frob_file_after_relocs (void)
18682 unsigned int count
, i
;
18684 syms
= bfd_get_outsymbols (stdoutput
);
18685 count
= bfd_get_symcount (stdoutput
);
18686 for (i
= 0; i
< count
; i
++, syms
++)
18687 if (ELF_ST_IS_COMPRESSED (elf_symbol (*syms
)->internal_elf_sym
.st_other
)
18688 && ((*syms
)->value
& 1) != 0)
18690 (*syms
)->value
&= ~1;
18691 /* If the symbol has an odd size, it was probably computed
18692 incorrectly, so adjust that as well. */
18693 if ((elf_symbol (*syms
)->internal_elf_sym
.st_size
& 1) != 0)
18694 ++elf_symbol (*syms
)->internal_elf_sym
.st_size
;
18698 /* This function is called whenever a label is defined, including fake
18699 labels instantiated off the dot special symbol. It is used when
18700 handling branch delays; if a branch has a label, we assume we cannot
18701 move it. This also bumps the value of the symbol by 1 in compressed
18705 mips_record_label (symbolS
*sym
)
18707 segment_info_type
*si
= seg_info (now_seg
);
18708 struct insn_label_list
*l
;
18710 if (free_insn_labels
== NULL
)
18711 l
= (struct insn_label_list
*) xmalloc (sizeof *l
);
18714 l
= free_insn_labels
;
18715 free_insn_labels
= l
->next
;
18719 l
->next
= si
->label_list
;
18720 si
->label_list
= l
;
18723 /* This function is called as tc_frob_label() whenever a label is defined
18724 and adds a DWARF-2 record we only want for true labels. */
18727 mips_define_label (symbolS
*sym
)
18729 mips_record_label (sym
);
18730 dwarf2_emit_label (sym
);
18733 /* This function is called by tc_new_dot_label whenever a new dot symbol
18737 mips_add_dot_label (symbolS
*sym
)
18739 mips_record_label (sym
);
18740 if (mips_assembling_insn
&& HAVE_CODE_COMPRESSION
)
18741 mips_compressed_mark_label (sym
);
18744 /* Some special processing for a MIPS ELF file. */
18747 mips_elf_final_processing (void)
18749 /* Write out the register information. */
18750 if (mips_abi
!= N64_ABI
)
18754 s
.ri_gprmask
= mips_gprmask
;
18755 s
.ri_cprmask
[0] = mips_cprmask
[0];
18756 s
.ri_cprmask
[1] = mips_cprmask
[1];
18757 s
.ri_cprmask
[2] = mips_cprmask
[2];
18758 s
.ri_cprmask
[3] = mips_cprmask
[3];
18759 /* The gp_value field is set by the MIPS ELF backend. */
18761 bfd_mips_elf32_swap_reginfo_out (stdoutput
, &s
,
18762 ((Elf32_External_RegInfo
*)
18763 mips_regmask_frag
));
18767 Elf64_Internal_RegInfo s
;
18769 s
.ri_gprmask
= mips_gprmask
;
18771 s
.ri_cprmask
[0] = mips_cprmask
[0];
18772 s
.ri_cprmask
[1] = mips_cprmask
[1];
18773 s
.ri_cprmask
[2] = mips_cprmask
[2];
18774 s
.ri_cprmask
[3] = mips_cprmask
[3];
18775 /* The gp_value field is set by the MIPS ELF backend. */
18777 bfd_mips_elf64_swap_reginfo_out (stdoutput
, &s
,
18778 ((Elf64_External_RegInfo
*)
18779 mips_regmask_frag
));
18782 /* Set the MIPS ELF flag bits. FIXME: There should probably be some
18783 sort of BFD interface for this. */
18784 if (mips_any_noreorder
)
18785 elf_elfheader (stdoutput
)->e_flags
|= EF_MIPS_NOREORDER
;
18786 if (mips_pic
!= NO_PIC
)
18788 elf_elfheader (stdoutput
)->e_flags
|= EF_MIPS_PIC
;
18789 elf_elfheader (stdoutput
)->e_flags
|= EF_MIPS_CPIC
;
18792 elf_elfheader (stdoutput
)->e_flags
|= EF_MIPS_CPIC
;
18794 /* Set MIPS ELF flags for ASEs. Note that not all ASEs have flags
18795 defined at present; this might need to change in future. */
18796 if (file_ase_mips16
)
18797 elf_elfheader (stdoutput
)->e_flags
|= EF_MIPS_ARCH_ASE_M16
;
18798 if (file_ase_micromips
)
18799 elf_elfheader (stdoutput
)->e_flags
|= EF_MIPS_ARCH_ASE_MICROMIPS
;
18800 if (file_ase
& ASE_MDMX
)
18801 elf_elfheader (stdoutput
)->e_flags
|= EF_MIPS_ARCH_ASE_MDMX
;
18803 /* Set the MIPS ELF ABI flags. */
18804 if (mips_abi
== O32_ABI
&& USE_E_MIPS_ABI_O32
)
18805 elf_elfheader (stdoutput
)->e_flags
|= E_MIPS_ABI_O32
;
18806 else if (mips_abi
== O64_ABI
)
18807 elf_elfheader (stdoutput
)->e_flags
|= E_MIPS_ABI_O64
;
18808 else if (mips_abi
== EABI_ABI
)
18810 if (!file_mips_gp32
)
18811 elf_elfheader (stdoutput
)->e_flags
|= E_MIPS_ABI_EABI64
;
18813 elf_elfheader (stdoutput
)->e_flags
|= E_MIPS_ABI_EABI32
;
18815 else if (mips_abi
== N32_ABI
)
18816 elf_elfheader (stdoutput
)->e_flags
|= EF_MIPS_ABI2
;
18818 /* Nothing to do for N64_ABI. */
18820 if (mips_32bitmode
)
18821 elf_elfheader (stdoutput
)->e_flags
|= EF_MIPS_32BITMODE
;
18823 #if 0 /* XXX FIXME */
18824 /* 32 bit code with 64 bit FP registers. */
18825 if (!file_mips_fp32
&& ABI_NEEDS_32BIT_REGS (mips_abi
))
18826 elf_elfheader (stdoutput
)->e_flags
|= ???;
18830 typedef struct proc
{
18832 symbolS
*func_end_sym
;
18833 unsigned long reg_mask
;
18834 unsigned long reg_offset
;
18835 unsigned long fpreg_mask
;
18836 unsigned long fpreg_offset
;
18837 unsigned long frame_offset
;
18838 unsigned long frame_reg
;
18839 unsigned long pc_reg
;
18842 static procS cur_proc
;
18843 static procS
*cur_proc_ptr
;
18844 static int numprocs
;
18846 /* Implement NOP_OPCODE. We encode a MIPS16 nop as "1", a microMIPS nop
18847 as "2", and a normal nop as "0". */
18849 #define NOP_OPCODE_MIPS 0
18850 #define NOP_OPCODE_MIPS16 1
18851 #define NOP_OPCODE_MICROMIPS 2
18854 mips_nop_opcode (void)
18856 if (seg_info (now_seg
)->tc_segment_info_data
.micromips
)
18857 return NOP_OPCODE_MICROMIPS
;
18858 else if (seg_info (now_seg
)->tc_segment_info_data
.mips16
)
18859 return NOP_OPCODE_MIPS16
;
18861 return NOP_OPCODE_MIPS
;
18864 /* Fill in an rs_align_code fragment. Unlike elsewhere we want to use
18865 32-bit microMIPS NOPs here (if applicable). */
18868 mips_handle_align (fragS
*fragp
)
18872 int bytes
, size
, excess
;
18875 if (fragp
->fr_type
!= rs_align_code
)
18878 p
= fragp
->fr_literal
+ fragp
->fr_fix
;
18880 switch (nop_opcode
)
18882 case NOP_OPCODE_MICROMIPS
:
18883 opcode
= micromips_nop32_insn
.insn_opcode
;
18886 case NOP_OPCODE_MIPS16
:
18887 opcode
= mips16_nop_insn
.insn_opcode
;
18890 case NOP_OPCODE_MIPS
:
18892 opcode
= nop_insn
.insn_opcode
;
18897 bytes
= fragp
->fr_next
->fr_address
- fragp
->fr_address
- fragp
->fr_fix
;
18898 excess
= bytes
% size
;
18900 /* Handle the leading part if we're not inserting a whole number of
18901 instructions, and make it the end of the fixed part of the frag.
18902 Try to fit in a short microMIPS NOP if applicable and possible,
18903 and use zeroes otherwise. */
18904 gas_assert (excess
< 4);
18905 fragp
->fr_fix
+= excess
;
18910 /* Fall through. */
18912 if (nop_opcode
== NOP_OPCODE_MICROMIPS
&& !mips_opts
.insn32
)
18914 p
= write_compressed_insn (p
, micromips_nop16_insn
.insn_opcode
, 2);
18918 /* Fall through. */
18921 /* Fall through. */
18926 md_number_to_chars (p
, opcode
, size
);
18927 fragp
->fr_var
= size
;
18931 md_obj_begin (void)
18938 /* Check for premature end, nesting errors, etc. */
18940 as_warn (_("missing .end at end of assembly"));
18949 if (*input_line_pointer
== '-')
18951 ++input_line_pointer
;
18954 if (!ISDIGIT (*input_line_pointer
))
18955 as_bad (_("expected simple number"));
18956 if (input_line_pointer
[0] == '0')
18958 if (input_line_pointer
[1] == 'x')
18960 input_line_pointer
+= 2;
18961 while (ISXDIGIT (*input_line_pointer
))
18964 val
|= hex_value (*input_line_pointer
++);
18966 return negative
? -val
: val
;
18970 ++input_line_pointer
;
18971 while (ISDIGIT (*input_line_pointer
))
18974 val
|= *input_line_pointer
++ - '0';
18976 return negative
? -val
: val
;
18979 if (!ISDIGIT (*input_line_pointer
))
18981 printf (_(" *input_line_pointer == '%c' 0x%02x\n"),
18982 *input_line_pointer
, *input_line_pointer
);
18983 as_warn (_("invalid number"));
18986 while (ISDIGIT (*input_line_pointer
))
18989 val
+= *input_line_pointer
++ - '0';
18991 return negative
? -val
: val
;
18994 /* The .file directive; just like the usual .file directive, but there
18995 is an initial number which is the ECOFF file index. In the non-ECOFF
18996 case .file implies DWARF-2. */
18999 s_mips_file (int x ATTRIBUTE_UNUSED
)
19001 static int first_file_directive
= 0;
19003 if (ECOFF_DEBUGGING
)
19012 filename
= dwarf2_directive_file (0);
19014 /* Versions of GCC up to 3.1 start files with a ".file"
19015 directive even for stabs output. Make sure that this
19016 ".file" is handled. Note that you need a version of GCC
19017 after 3.1 in order to support DWARF-2 on MIPS. */
19018 if (filename
!= NULL
&& ! first_file_directive
)
19020 (void) new_logical_line (filename
, -1);
19021 s_app_file_string (filename
, 0);
19023 first_file_directive
= 1;
19027 /* The .loc directive, implying DWARF-2. */
19030 s_mips_loc (int x ATTRIBUTE_UNUSED
)
19032 if (!ECOFF_DEBUGGING
)
19033 dwarf2_directive_loc (0);
19036 /* The .end directive. */
19039 s_mips_end (int x ATTRIBUTE_UNUSED
)
19043 /* Following functions need their own .frame and .cprestore directives. */
19044 mips_frame_reg_valid
= 0;
19045 mips_cprestore_valid
= 0;
19047 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
19050 demand_empty_rest_of_line ();
19055 if ((bfd_get_section_flags (stdoutput
, now_seg
) & SEC_CODE
) == 0)
19056 as_warn (_(".end not in text section"));
19060 as_warn (_(".end directive without a preceding .ent directive."));
19061 demand_empty_rest_of_line ();
19067 gas_assert (S_GET_NAME (p
));
19068 if (strcmp (S_GET_NAME (p
), S_GET_NAME (cur_proc_ptr
->func_sym
)))
19069 as_warn (_(".end symbol does not match .ent symbol."));
19071 if (debug_type
== DEBUG_STABS
)
19072 stabs_generate_asm_endfunc (S_GET_NAME (p
),
19076 as_warn (_(".end directive missing or unknown symbol"));
19078 /* Create an expression to calculate the size of the function. */
19079 if (p
&& cur_proc_ptr
)
19081 OBJ_SYMFIELD_TYPE
*obj
= symbol_get_obj (p
);
19082 expressionS
*exp
= xmalloc (sizeof (expressionS
));
19085 exp
->X_op
= O_subtract
;
19086 exp
->X_add_symbol
= symbol_temp_new_now ();
19087 exp
->X_op_symbol
= p
;
19088 exp
->X_add_number
= 0;
19090 cur_proc_ptr
->func_end_sym
= exp
->X_add_symbol
;
19093 /* Generate a .pdr section. */
19094 if (!ECOFF_DEBUGGING
&& mips_flag_pdr
)
19096 segT saved_seg
= now_seg
;
19097 subsegT saved_subseg
= now_subseg
;
19101 #ifdef md_flush_pending_output
19102 md_flush_pending_output ();
19105 gas_assert (pdr_seg
);
19106 subseg_set (pdr_seg
, 0);
19108 /* Write the symbol. */
19109 exp
.X_op
= O_symbol
;
19110 exp
.X_add_symbol
= p
;
19111 exp
.X_add_number
= 0;
19112 emit_expr (&exp
, 4);
19114 fragp
= frag_more (7 * 4);
19116 md_number_to_chars (fragp
, cur_proc_ptr
->reg_mask
, 4);
19117 md_number_to_chars (fragp
+ 4, cur_proc_ptr
->reg_offset
, 4);
19118 md_number_to_chars (fragp
+ 8, cur_proc_ptr
->fpreg_mask
, 4);
19119 md_number_to_chars (fragp
+ 12, cur_proc_ptr
->fpreg_offset
, 4);
19120 md_number_to_chars (fragp
+ 16, cur_proc_ptr
->frame_offset
, 4);
19121 md_number_to_chars (fragp
+ 20, cur_proc_ptr
->frame_reg
, 4);
19122 md_number_to_chars (fragp
+ 24, cur_proc_ptr
->pc_reg
, 4);
19124 subseg_set (saved_seg
, saved_subseg
);
19127 cur_proc_ptr
= NULL
;
19130 /* The .aent and .ent directives. */
19133 s_mips_ent (int aent
)
19137 symbolP
= get_symbol ();
19138 if (*input_line_pointer
== ',')
19139 ++input_line_pointer
;
19140 SKIP_WHITESPACE ();
19141 if (ISDIGIT (*input_line_pointer
)
19142 || *input_line_pointer
== '-')
19145 if ((bfd_get_section_flags (stdoutput
, now_seg
) & SEC_CODE
) == 0)
19146 as_warn (_(".ent or .aent not in text section."));
19148 if (!aent
&& cur_proc_ptr
)
19149 as_warn (_("missing .end"));
19153 /* This function needs its own .frame and .cprestore directives. */
19154 mips_frame_reg_valid
= 0;
19155 mips_cprestore_valid
= 0;
19157 cur_proc_ptr
= &cur_proc
;
19158 memset (cur_proc_ptr
, '\0', sizeof (procS
));
19160 cur_proc_ptr
->func_sym
= symbolP
;
19164 if (debug_type
== DEBUG_STABS
)
19165 stabs_generate_asm_func (S_GET_NAME (symbolP
),
19166 S_GET_NAME (symbolP
));
19169 symbol_get_bfdsym (symbolP
)->flags
|= BSF_FUNCTION
;
19171 demand_empty_rest_of_line ();
19174 /* The .frame directive. If the mdebug section is present (IRIX 5 native)
19175 then ecoff.c (ecoff_directive_frame) is used. For embedded targets,
19176 s_mips_frame is used so that we can set the PDR information correctly.
19177 We can't use the ecoff routines because they make reference to the ecoff
19178 symbol table (in the mdebug section). */
19181 s_mips_frame (int ignore ATTRIBUTE_UNUSED
)
19183 if (ECOFF_DEBUGGING
)
19189 if (cur_proc_ptr
== (procS
*) NULL
)
19191 as_warn (_(".frame outside of .ent"));
19192 demand_empty_rest_of_line ();
19196 cur_proc_ptr
->frame_reg
= tc_get_register (1);
19198 SKIP_WHITESPACE ();
19199 if (*input_line_pointer
++ != ','
19200 || get_absolute_expression_and_terminator (&val
) != ',')
19202 as_warn (_("Bad .frame directive"));
19203 --input_line_pointer
;
19204 demand_empty_rest_of_line ();
19208 cur_proc_ptr
->frame_offset
= val
;
19209 cur_proc_ptr
->pc_reg
= tc_get_register (0);
19211 demand_empty_rest_of_line ();
19215 /* The .fmask and .mask directives. If the mdebug section is present
19216 (IRIX 5 native) then ecoff.c (ecoff_directive_mask) is used. For
19217 embedded targets, s_mips_mask is used so that we can set the PDR
19218 information correctly. We can't use the ecoff routines because they
19219 make reference to the ecoff symbol table (in the mdebug section). */
19222 s_mips_mask (int reg_type
)
19224 if (ECOFF_DEBUGGING
)
19225 s_ignore (reg_type
);
19230 if (cur_proc_ptr
== (procS
*) NULL
)
19232 as_warn (_(".mask/.fmask outside of .ent"));
19233 demand_empty_rest_of_line ();
19237 if (get_absolute_expression_and_terminator (&mask
) != ',')
19239 as_warn (_("Bad .mask/.fmask directive"));
19240 --input_line_pointer
;
19241 demand_empty_rest_of_line ();
19245 off
= get_absolute_expression ();
19247 if (reg_type
== 'F')
19249 cur_proc_ptr
->fpreg_mask
= mask
;
19250 cur_proc_ptr
->fpreg_offset
= off
;
19254 cur_proc_ptr
->reg_mask
= mask
;
19255 cur_proc_ptr
->reg_offset
= off
;
19258 demand_empty_rest_of_line ();
19262 /* A table describing all the processors gas knows about. Names are
19263 matched in the order listed.
19265 To ease comparison, please keep this table in the same order as
19266 gcc's mips_cpu_info_table[]. */
19267 static const struct mips_cpu_info mips_cpu_info_table
[] =
19269 /* Entries for generic ISAs */
19270 { "mips1", MIPS_CPU_IS_ISA
, 0, ISA_MIPS1
, CPU_R3000
},
19271 { "mips2", MIPS_CPU_IS_ISA
, 0, ISA_MIPS2
, CPU_R6000
},
19272 { "mips3", MIPS_CPU_IS_ISA
, 0, ISA_MIPS3
, CPU_R4000
},
19273 { "mips4", MIPS_CPU_IS_ISA
, 0, ISA_MIPS4
, CPU_R8000
},
19274 { "mips5", MIPS_CPU_IS_ISA
, 0, ISA_MIPS5
, CPU_MIPS5
},
19275 { "mips32", MIPS_CPU_IS_ISA
, 0, ISA_MIPS32
, CPU_MIPS32
},
19276 { "mips32r2", MIPS_CPU_IS_ISA
, 0, ISA_MIPS32R2
, CPU_MIPS32R2
},
19277 { "mips64", MIPS_CPU_IS_ISA
, 0, ISA_MIPS64
, CPU_MIPS64
},
19278 { "mips64r2", MIPS_CPU_IS_ISA
, 0, ISA_MIPS64R2
, CPU_MIPS64R2
},
19281 { "r3000", 0, 0, ISA_MIPS1
, CPU_R3000
},
19282 { "r2000", 0, 0, ISA_MIPS1
, CPU_R3000
},
19283 { "r3900", 0, 0, ISA_MIPS1
, CPU_R3900
},
19286 { "r6000", 0, 0, ISA_MIPS2
, CPU_R6000
},
19289 { "r4000", 0, 0, ISA_MIPS3
, CPU_R4000
},
19290 { "r4010", 0, 0, ISA_MIPS2
, CPU_R4010
},
19291 { "vr4100", 0, 0, ISA_MIPS3
, CPU_VR4100
},
19292 { "vr4111", 0, 0, ISA_MIPS3
, CPU_R4111
},
19293 { "vr4120", 0, 0, ISA_MIPS3
, CPU_VR4120
},
19294 { "vr4130", 0, 0, ISA_MIPS3
, CPU_VR4120
},
19295 { "vr4181", 0, 0, ISA_MIPS3
, CPU_R4111
},
19296 { "vr4300", 0, 0, ISA_MIPS3
, CPU_R4300
},
19297 { "r4400", 0, 0, ISA_MIPS3
, CPU_R4400
},
19298 { "r4600", 0, 0, ISA_MIPS3
, CPU_R4600
},
19299 { "orion", 0, 0, ISA_MIPS3
, CPU_R4600
},
19300 { "r4650", 0, 0, ISA_MIPS3
, CPU_R4650
},
19301 { "r5900", 0, 0, ISA_MIPS3
, CPU_R5900
},
19302 /* ST Microelectronics Loongson 2E and 2F cores */
19303 { "loongson2e", 0, 0, ISA_MIPS3
, CPU_LOONGSON_2E
},
19304 { "loongson2f", 0, 0, ISA_MIPS3
, CPU_LOONGSON_2F
},
19307 { "r8000", 0, 0, ISA_MIPS4
, CPU_R8000
},
19308 { "r10000", 0, 0, ISA_MIPS4
, CPU_R10000
},
19309 { "r12000", 0, 0, ISA_MIPS4
, CPU_R12000
},
19310 { "r14000", 0, 0, ISA_MIPS4
, CPU_R14000
},
19311 { "r16000", 0, 0, ISA_MIPS4
, CPU_R16000
},
19312 { "vr5000", 0, 0, ISA_MIPS4
, CPU_R5000
},
19313 { "vr5400", 0, 0, ISA_MIPS4
, CPU_VR5400
},
19314 { "vr5500", 0, 0, ISA_MIPS4
, CPU_VR5500
},
19315 { "rm5200", 0, 0, ISA_MIPS4
, CPU_R5000
},
19316 { "rm5230", 0, 0, ISA_MIPS4
, CPU_R5000
},
19317 { "rm5231", 0, 0, ISA_MIPS4
, CPU_R5000
},
19318 { "rm5261", 0, 0, ISA_MIPS4
, CPU_R5000
},
19319 { "rm5721", 0, 0, ISA_MIPS4
, CPU_R5000
},
19320 { "rm7000", 0, 0, ISA_MIPS4
, CPU_RM7000
},
19321 { "rm9000", 0, 0, ISA_MIPS4
, CPU_RM9000
},
19324 { "4kc", 0, 0, ISA_MIPS32
, CPU_MIPS32
},
19325 { "4km", 0, 0, ISA_MIPS32
, CPU_MIPS32
},
19326 { "4kp", 0, 0, ISA_MIPS32
, CPU_MIPS32
},
19327 { "4ksc", 0, ASE_SMARTMIPS
, ISA_MIPS32
, CPU_MIPS32
},
19329 /* MIPS 32 Release 2 */
19330 { "4kec", 0, 0, ISA_MIPS32R2
, CPU_MIPS32R2
},
19331 { "4kem", 0, 0, ISA_MIPS32R2
, CPU_MIPS32R2
},
19332 { "4kep", 0, 0, ISA_MIPS32R2
, CPU_MIPS32R2
},
19333 { "4ksd", 0, ASE_SMARTMIPS
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19334 { "m4k", 0, 0, ISA_MIPS32R2
, CPU_MIPS32R2
},
19335 { "m4kp", 0, 0, ISA_MIPS32R2
, CPU_MIPS32R2
},
19336 { "m14k", 0, ASE_MCU
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19337 { "m14kc", 0, ASE_MCU
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19338 { "m14ke", 0, ASE_DSP
| ASE_DSPR2
| ASE_MCU
,
19339 ISA_MIPS32R2
, CPU_MIPS32R2
},
19340 { "m14kec", 0, ASE_DSP
| ASE_DSPR2
| ASE_MCU
,
19341 ISA_MIPS32R2
, CPU_MIPS32R2
},
19342 { "24kc", 0, 0, ISA_MIPS32R2
, CPU_MIPS32R2
},
19343 { "24kf2_1", 0, 0, ISA_MIPS32R2
, CPU_MIPS32R2
},
19344 { "24kf", 0, 0, ISA_MIPS32R2
, CPU_MIPS32R2
},
19345 { "24kf1_1", 0, 0, ISA_MIPS32R2
, CPU_MIPS32R2
},
19346 /* Deprecated forms of the above. */
19347 { "24kfx", 0, 0, ISA_MIPS32R2
, CPU_MIPS32R2
},
19348 { "24kx", 0, 0, ISA_MIPS32R2
, CPU_MIPS32R2
},
19349 /* 24KE is a 24K with DSP ASE, other ASEs are optional. */
19350 { "24kec", 0, ASE_DSP
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19351 { "24kef2_1", 0, ASE_DSP
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19352 { "24kef", 0, ASE_DSP
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19353 { "24kef1_1", 0, ASE_DSP
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19354 /* Deprecated forms of the above. */
19355 { "24kefx", 0, ASE_DSP
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19356 { "24kex", 0, ASE_DSP
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19357 /* 34K is a 24K with DSP and MT ASE, other ASEs are optional. */
19358 { "34kc", 0, ASE_DSP
| ASE_MT
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19359 { "34kf2_1", 0, ASE_DSP
| ASE_MT
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19360 { "34kf", 0, ASE_DSP
| ASE_MT
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19361 { "34kf1_1", 0, ASE_DSP
| ASE_MT
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19362 /* Deprecated forms of the above. */
19363 { "34kfx", 0, ASE_DSP
| ASE_MT
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19364 { "34kx", 0, ASE_DSP
| ASE_MT
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19365 /* 34Kn is a 34kc without DSP. */
19366 { "34kn", 0, ASE_MT
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19367 /* 74K with DSP and DSPR2 ASE, other ASEs are optional. */
19368 { "74kc", 0, ASE_DSP
| ASE_DSPR2
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19369 { "74kf2_1", 0, ASE_DSP
| ASE_DSPR2
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19370 { "74kf", 0, ASE_DSP
| ASE_DSPR2
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19371 { "74kf1_1", 0, ASE_DSP
| ASE_DSPR2
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19372 { "74kf3_2", 0, ASE_DSP
| ASE_DSPR2
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19373 /* Deprecated forms of the above. */
19374 { "74kfx", 0, ASE_DSP
| ASE_DSPR2
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19375 { "74kx", 0, ASE_DSP
| ASE_DSPR2
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19376 /* 1004K cores are multiprocessor versions of the 34K. */
19377 { "1004kc", 0, ASE_DSP
| ASE_MT
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19378 { "1004kf2_1", 0, ASE_DSP
| ASE_MT
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19379 { "1004kf", 0, ASE_DSP
| ASE_MT
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19380 { "1004kf1_1", 0, ASE_DSP
| ASE_MT
, ISA_MIPS32R2
, CPU_MIPS32R2
},
19383 { "5kc", 0, 0, ISA_MIPS64
, CPU_MIPS64
},
19384 { "5kf", 0, 0, ISA_MIPS64
, CPU_MIPS64
},
19385 { "20kc", 0, ASE_MIPS3D
, ISA_MIPS64
, CPU_MIPS64
},
19386 { "25kf", 0, ASE_MIPS3D
, ISA_MIPS64
, CPU_MIPS64
},
19388 /* Broadcom SB-1 CPU core */
19389 { "sb1", 0, ASE_MIPS3D
| ASE_MDMX
, ISA_MIPS64
, CPU_SB1
},
19390 /* Broadcom SB-1A CPU core */
19391 { "sb1a", 0, ASE_MIPS3D
| ASE_MDMX
, ISA_MIPS64
, CPU_SB1
},
19393 { "loongson3a", 0, 0, ISA_MIPS64
, CPU_LOONGSON_3A
},
19395 /* MIPS 64 Release 2 */
19397 /* Cavium Networks Octeon CPU core */
19398 { "octeon", 0, 0, ISA_MIPS64R2
, CPU_OCTEON
},
19399 { "octeon+", 0, 0, ISA_MIPS64R2
, CPU_OCTEONP
},
19400 { "octeon2", 0, 0, ISA_MIPS64R2
, CPU_OCTEON2
},
19403 { "xlr", 0, 0, ISA_MIPS64
, CPU_XLR
},
19406 XLP is mostly like XLR, with the prominent exception that it is
19407 MIPS64R2 rather than MIPS64. */
19408 { "xlp", 0, 0, ISA_MIPS64R2
, CPU_XLR
},
19411 { NULL
, 0, 0, 0, 0 }
19415 /* Return true if GIVEN is the same as CANONICAL, or if it is CANONICAL
19416 with a final "000" replaced by "k". Ignore case.
19418 Note: this function is shared between GCC and GAS. */
19421 mips_strict_matching_cpu_name_p (const char *canonical
, const char *given
)
19423 while (*given
!= 0 && TOLOWER (*given
) == TOLOWER (*canonical
))
19424 given
++, canonical
++;
19426 return ((*given
== 0 && *canonical
== 0)
19427 || (strcmp (canonical
, "000") == 0 && strcasecmp (given
, "k") == 0));
19431 /* Return true if GIVEN matches CANONICAL, where GIVEN is a user-supplied
19432 CPU name. We've traditionally allowed a lot of variation here.
19434 Note: this function is shared between GCC and GAS. */
19437 mips_matching_cpu_name_p (const char *canonical
, const char *given
)
19439 /* First see if the name matches exactly, or with a final "000"
19440 turned into "k". */
19441 if (mips_strict_matching_cpu_name_p (canonical
, given
))
19444 /* If not, try comparing based on numerical designation alone.
19445 See if GIVEN is an unadorned number, or 'r' followed by a number. */
19446 if (TOLOWER (*given
) == 'r')
19448 if (!ISDIGIT (*given
))
19451 /* Skip over some well-known prefixes in the canonical name,
19452 hoping to find a number there too. */
19453 if (TOLOWER (canonical
[0]) == 'v' && TOLOWER (canonical
[1]) == 'r')
19455 else if (TOLOWER (canonical
[0]) == 'r' && TOLOWER (canonical
[1]) == 'm')
19457 else if (TOLOWER (canonical
[0]) == 'r')
19460 return mips_strict_matching_cpu_name_p (canonical
, given
);
19464 /* Parse an option that takes the name of a processor as its argument.
19465 OPTION is the name of the option and CPU_STRING is the argument.
19466 Return the corresponding processor enumeration if the CPU_STRING is
19467 recognized, otherwise report an error and return null.
19469 A similar function exists in GCC. */
19471 static const struct mips_cpu_info
*
19472 mips_parse_cpu (const char *option
, const char *cpu_string
)
19474 const struct mips_cpu_info
*p
;
19476 /* 'from-abi' selects the most compatible architecture for the given
19477 ABI: MIPS I for 32-bit ABIs and MIPS III for 64-bit ABIs. For the
19478 EABIs, we have to decide whether we're using the 32-bit or 64-bit
19479 version. Look first at the -mgp options, if given, otherwise base
19480 the choice on MIPS_DEFAULT_64BIT.
19482 Treat NO_ABI like the EABIs. One reason to do this is that the
19483 plain 'mips' and 'mips64' configs have 'from-abi' as their default
19484 architecture. This code picks MIPS I for 'mips' and MIPS III for
19485 'mips64', just as we did in the days before 'from-abi'. */
19486 if (strcasecmp (cpu_string
, "from-abi") == 0)
19488 if (ABI_NEEDS_32BIT_REGS (mips_abi
))
19489 return mips_cpu_info_from_isa (ISA_MIPS1
);
19491 if (ABI_NEEDS_64BIT_REGS (mips_abi
))
19492 return mips_cpu_info_from_isa (ISA_MIPS3
);
19494 if (file_mips_gp32
>= 0)
19495 return mips_cpu_info_from_isa (file_mips_gp32
? ISA_MIPS1
: ISA_MIPS3
);
19497 return mips_cpu_info_from_isa (MIPS_DEFAULT_64BIT
19502 /* 'default' has traditionally been a no-op. Probably not very useful. */
19503 if (strcasecmp (cpu_string
, "default") == 0)
19506 for (p
= mips_cpu_info_table
; p
->name
!= 0; p
++)
19507 if (mips_matching_cpu_name_p (p
->name
, cpu_string
))
19510 as_bad (_("Bad value (%s) for %s"), cpu_string
, option
);
19514 /* Return the canonical processor information for ISA (a member of the
19515 ISA_MIPS* enumeration). */
19517 static const struct mips_cpu_info
*
19518 mips_cpu_info_from_isa (int isa
)
19522 for (i
= 0; mips_cpu_info_table
[i
].name
!= NULL
; i
++)
19523 if ((mips_cpu_info_table
[i
].flags
& MIPS_CPU_IS_ISA
)
19524 && isa
== mips_cpu_info_table
[i
].isa
)
19525 return (&mips_cpu_info_table
[i
]);
19530 static const struct mips_cpu_info
*
19531 mips_cpu_info_from_arch (int arch
)
19535 for (i
= 0; mips_cpu_info_table
[i
].name
!= NULL
; i
++)
19536 if (arch
== mips_cpu_info_table
[i
].cpu
)
19537 return (&mips_cpu_info_table
[i
]);
19543 show (FILE *stream
, const char *string
, int *col_p
, int *first_p
)
19547 fprintf (stream
, "%24s", "");
19552 fprintf (stream
, ", ");
19556 if (*col_p
+ strlen (string
) > 72)
19558 fprintf (stream
, "\n%24s", "");
19562 fprintf (stream
, "%s", string
);
19563 *col_p
+= strlen (string
);
19569 md_show_usage (FILE *stream
)
19574 fprintf (stream
, _("\
19576 -EB generate big endian output\n\
19577 -EL generate little endian output\n\
19578 -g, -g2 do not remove unneeded NOPs or swap branches\n\
19579 -G NUM allow referencing objects up to NUM bytes\n\
19580 implicitly with the gp register [default 8]\n"));
19581 fprintf (stream
, _("\
19582 -mips1 generate MIPS ISA I instructions\n\
19583 -mips2 generate MIPS ISA II instructions\n\
19584 -mips3 generate MIPS ISA III instructions\n\
19585 -mips4 generate MIPS ISA IV instructions\n\
19586 -mips5 generate MIPS ISA V instructions\n\
19587 -mips32 generate MIPS32 ISA instructions\n\
19588 -mips32r2 generate MIPS32 release 2 ISA instructions\n\
19589 -mips64 generate MIPS64 ISA instructions\n\
19590 -mips64r2 generate MIPS64 release 2 ISA instructions\n\
19591 -march=CPU/-mtune=CPU generate code/schedule for CPU, where CPU is one of:\n"));
19595 for (i
= 0; mips_cpu_info_table
[i
].name
!= NULL
; i
++)
19596 show (stream
, mips_cpu_info_table
[i
].name
, &column
, &first
);
19597 show (stream
, "from-abi", &column
, &first
);
19598 fputc ('\n', stream
);
19600 fprintf (stream
, _("\
19601 -mCPU equivalent to -march=CPU -mtune=CPU. Deprecated.\n\
19602 -no-mCPU don't generate code specific to CPU.\n\
19603 For -mCPU and -no-mCPU, CPU must be one of:\n"));
19607 show (stream
, "3900", &column
, &first
);
19608 show (stream
, "4010", &column
, &first
);
19609 show (stream
, "4100", &column
, &first
);
19610 show (stream
, "4650", &column
, &first
);
19611 fputc ('\n', stream
);
19613 fprintf (stream
, _("\
19614 -mips16 generate mips16 instructions\n\
19615 -no-mips16 do not generate mips16 instructions\n"));
19616 fprintf (stream
, _("\
19617 -mmicromips generate microMIPS instructions\n\
19618 -mno-micromips do not generate microMIPS instructions\n"));
19619 fprintf (stream
, _("\
19620 -msmartmips generate smartmips instructions\n\
19621 -mno-smartmips do not generate smartmips instructions\n"));
19622 fprintf (stream
, _("\
19623 -mdsp generate DSP instructions\n\
19624 -mno-dsp do not generate DSP instructions\n"));
19625 fprintf (stream
, _("\
19626 -mdspr2 generate DSP R2 instructions\n\
19627 -mno-dspr2 do not generate DSP R2 instructions\n"));
19628 fprintf (stream
, _("\
19629 -mmt generate MT instructions\n\
19630 -mno-mt do not generate MT instructions\n"));
19631 fprintf (stream
, _("\
19632 -mmcu generate MCU instructions\n\
19633 -mno-mcu do not generate MCU instructions\n"));
19634 fprintf (stream
, _("\
19635 -mvirt generate Virtualization instructions\n\
19636 -mno-virt do not generate Virtualization instructions\n"));
19637 fprintf (stream
, _("\
19638 -minsn32 only generate 32-bit microMIPS instructions\n\
19639 -mno-insn32 generate all microMIPS instructions\n"));
19640 fprintf (stream
, _("\
19641 -mfix-loongson2f-jump work around Loongson2F JUMP instructions\n\
19642 -mfix-loongson2f-nop work around Loongson2F NOP errata\n\
19643 -mfix-vr4120 work around certain VR4120 errata\n\
19644 -mfix-vr4130 work around VR4130 mflo/mfhi errata\n\
19645 -mfix-24k insert a nop after ERET and DERET instructions\n\
19646 -mfix-cn63xxp1 work around CN63XXP1 PREF errata\n\
19647 -mgp32 use 32-bit GPRs, regardless of the chosen ISA\n\
19648 -mfp32 use 32-bit FPRs, regardless of the chosen ISA\n\
19649 -msym32 assume all symbols have 32-bit values\n\
19650 -O0 remove unneeded NOPs, do not swap branches\n\
19651 -O remove unneeded NOPs and swap branches\n\
19652 --trap, --no-break trap exception on div by 0 and mult overflow\n\
19653 --break, --no-trap break exception on div by 0 and mult overflow\n"));
19654 fprintf (stream
, _("\
19655 -mhard-float allow floating-point instructions\n\
19656 -msoft-float do not allow floating-point instructions\n\
19657 -msingle-float only allow 32-bit floating-point operations\n\
19658 -mdouble-float allow 32-bit and 64-bit floating-point operations\n\
19659 --[no-]construct-floats [dis]allow floating point values to be constructed\n\
19660 --[no-]relax-branch [dis]allow out-of-range branches to be relaxed\n"
19662 fprintf (stream
, _("\
19663 -KPIC, -call_shared generate SVR4 position independent code\n\
19664 -call_nonpic generate non-PIC code that can operate with DSOs\n\
19665 -mvxworks-pic generate VxWorks position independent code\n\
19666 -non_shared do not generate code that can operate with DSOs\n\
19667 -xgot assume a 32 bit GOT\n\
19668 -mpdr, -mno-pdr enable/disable creation of .pdr sections\n\
19669 -mshared, -mno-shared disable/enable .cpload optimization for\n\
19670 position dependent (non shared) code\n\
19671 -mabi=ABI create ABI conformant object file for:\n"));
19675 show (stream
, "32", &column
, &first
);
19676 show (stream
, "o64", &column
, &first
);
19677 show (stream
, "n32", &column
, &first
);
19678 show (stream
, "64", &column
, &first
);
19679 show (stream
, "eabi", &column
, &first
);
19681 fputc ('\n', stream
);
19683 fprintf (stream
, _("\
19684 -32 create o32 ABI object file (default)\n\
19685 -n32 create n32 ABI object file\n\
19686 -64 create 64 ABI object file\n"));
19691 mips_dwarf2_format (asection
*sec ATTRIBUTE_UNUSED
)
19693 if (HAVE_64BIT_SYMBOLS
)
19694 return dwarf2_format_64bit_irix
;
19696 return dwarf2_format_32bit
;
19701 mips_dwarf2_addr_size (void)
19703 if (HAVE_64BIT_OBJECTS
)
19709 /* Standard calling conventions leave the CFA at SP on entry. */
19711 mips_cfi_frame_initial_instructions (void)
19713 cfi_add_CFA_def_cfa_register (SP
);
19717 tc_mips_regname_to_dw2regnum (char *regname
)
19719 unsigned int regnum
= -1;
19722 if (reg_lookup (®name
, RTYPE_GP
| RTYPE_NUM
, ®
))