1 /* spu.c -- Assembler for the IBM Synergistic Processing Unit (SPU)
3 Copyright 2006 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 #include "safe-ctype.h"
25 #include "opcode/spu.h"
26 #include "dwarf2dbg.h"
28 const struct spu_opcode spu_opcodes
[] = {
29 #define APUOP(TAG,MACFORMAT,OPCODE,MNEMONIC,ASMFORMAT,DEP,PIPE) \
30 { MACFORMAT, (OPCODE) << (32-11), MNEMONIC, ASMFORMAT },
31 #define APUOPFB(TAG,MACFORMAT,OPCODE,FB,MNEMONIC,ASMFORMAT,DEP,PIPE) \
32 { MACFORMAT, ((OPCODE) << (32-11)) | ((FB) << (32-18)), MNEMONIC, ASMFORMAT },
33 #include "opcode/spu-insns.h"
38 static const int spu_num_opcodes
=
39 sizeof (spu_opcodes
) / sizeof (spu_opcodes
[0]);
46 expressionS exp
[MAX_RELOCS
];
47 int reloc_arg
[MAX_RELOCS
];
52 static const char *get_imm (const char *param
, struct spu_insn
*insn
, int arg
);
53 static const char *get_reg (const char *param
, struct spu_insn
*insn
, int arg
,
56 static int calcop (struct spu_opcode
*format
, const char *param
,
57 struct spu_insn
*insn
);
60 static struct hash_control
*op_hash
= NULL
;
62 /* These bits should be turned off in the first address of every segment */
65 /* These chars start a comment anywhere in a source file (except inside
67 const char comment_chars
[] = "#";
69 /* These chars only start a comment at the beginning of a line. */
70 const char line_comment_chars
[] = "#";
72 /* gods own line continuation char */
73 const char line_separator_chars
[] = ";";
75 /* Chars that can be used to separate mant from exp in floating point nums */
76 const char EXP_CHARS
[] = "eE";
78 /* Chars that mean this number is a floating point constant */
80 /* or 0H1.234E-12 (see exp chars above) */
81 const char FLT_CHARS
[] = "dDfF";
83 const pseudo_typeS md_pseudo_table
[] =
85 {"align", s_align_ptwo
, 4},
87 {"dfloat", float_cons
, 'd'},
88 {"ffloat", float_cons
, 'f'},
89 {"global", s_globl
, 0},
91 {"bss", s_lcomm_bytes
, 1},
92 {"string", stringer
, 1},
94 /* Force set to be treated as an instruction. */
97 {"file", (void (*) PARAMS ((int))) dwarf2_directive_file
, 0 },
98 {"loc", dwarf2_directive_loc
, 0},
105 const char *retval
= NULL
;
108 /* initialize hash table */
110 op_hash
= hash_new ();
112 /* loop until you see the end of the list */
114 for (i
= 0; i
< spu_num_opcodes
; i
++)
116 /* hash each mnemonic and record its position */
118 retval
= hash_insert (op_hash
, spu_opcodes
[i
].mnemonic
, (PTR
)&spu_opcodes
[i
]);
120 if (retval
!= NULL
&& strcmp (retval
, "exists") != 0)
121 as_fatal (_("Can't hash instruction '%s':%s"),
122 spu_opcodes
[i
].mnemonic
, retval
);
126 const char *md_shortopts
= "";
127 struct option md_longopts
[] = {
128 #define OPTION_APUASM (OPTION_MD_BASE)
129 {"apuasm", no_argument
, NULL
, OPTION_APUASM
},
130 #define OPTION_DD2 (OPTION_MD_BASE+1)
131 {"mdd2.0", no_argument
, NULL
, OPTION_DD2
},
132 #define OPTION_DD1 (OPTION_MD_BASE+2)
133 {"mdd1.0", no_argument
, NULL
, OPTION_DD1
},
134 #define OPTION_DD3 (OPTION_MD_BASE+3)
135 {"mdd3.0", no_argument
, NULL
, OPTION_DD3
},
136 { NULL
, no_argument
, NULL
, 0 }
138 size_t md_longopts_size
= sizeof (md_longopts
);
140 /* When set (by -apuasm) our assembler emulates the behaviour of apuasm.
141 * e.g. don't add bias to float conversion and don't right shift
142 * immediate values. */
143 static int emulate_apuasm
;
145 /* Use the dd2.0 instructions set. The only differences are some new
146 * register names and the orx insn */
147 static int use_dd2
= 1;
150 md_parse_option (int c
, char *arg ATTRIBUTE_UNUSED
)
173 md_show_usage (FILE *stream
)
177 --apuasm emulate behaviour of apuasm\n"),
188 bfd_reloc_code_real_type reloc
;
191 static struct arg_encode arg_encode
[A_MAX
] = {
192 { 7, 0, 0, 0, 127, 0, -1, 0 }, /* A_T */
193 { 7, 7, 0, 0, 127, 0, -1, 0 }, /* A_A */
194 { 7, 14, 0, 0, 127, 0, -1, 0 }, /* A_B */
195 { 7, 21, 0, 0, 127, 0, -1, 0 }, /* A_C */
196 { 7, 7, 0, 0, 127, 0, -1, 0 }, /* A_S */
197 { 7, 7, 0, 0, 127, 0, -1, 0 }, /* A_H */
198 { 0, 0, 0, 0, -1, 0, -1, 0 }, /* A_P */
199 { 7, 14, 0, 0, -1, 0, -1, BFD_RELOC_SPU_IMM7
}, /* A_S3 */
200 { 7, 14, 0, -32, 31, -31, 0, BFD_RELOC_SPU_IMM7
}, /* A_S6 */
201 { 7, 14, 0, 0, -1, 0, -1, BFD_RELOC_SPU_IMM7
}, /* A_S7N */
202 { 7, 14, 0, -64, 63, -63, 0, BFD_RELOC_SPU_IMM7
}, /* A_S7 */
203 { 8, 14, 0, 0, 127, 0, -1, BFD_RELOC_SPU_IMM8
}, /* A_U7A */
204 { 8, 14, 0, 0, 127, 0, -1, BFD_RELOC_SPU_IMM8
}, /* A_U7B */
205 { 10, 14, 0, -512, 511, -128, 255, BFD_RELOC_SPU_IMM10
}, /* A_S10B */
206 { 10, 14, 0, -512, 511, 0, -1, BFD_RELOC_SPU_IMM10
}, /* A_S10 */
207 { 2, 23, 9, -1024, 1023, 0, -1, BFD_RELOC_SPU_PCREL9a
}, /* A_S11 */
208 { 2, 14, 9, -1024, 1023, 0, -1, BFD_RELOC_SPU_PCREL9b
}, /* A_S11I */
209 { 10, 14, 4, -8192, 8191, 0, -1, BFD_RELOC_SPU_IMM10W
}, /* A_S14 */
210 { 16, 7, 0, -32768, 32767, 0, -1, BFD_RELOC_SPU_IMM16
}, /* A_S16 */
211 { 16, 7, 2, -131072, 262143, 0, -1, BFD_RELOC_SPU_IMM16W
}, /* A_S18 */
212 { 16, 7, 2, -262144, 262143, 0, -1, BFD_RELOC_SPU_PCREL16
}, /* A_R18 */
213 { 7, 14, 0, 0, -1, 0, -1, BFD_RELOC_SPU_IMM7
}, /* A_U3 */
214 { 7, 14, 0, 0, 127, 0, 31, BFD_RELOC_SPU_IMM7
}, /* A_U5 */
215 { 7, 14, 0, 0, 127, 0, 63, BFD_RELOC_SPU_IMM7
}, /* A_U6 */
216 { 7, 14, 0, 0, -1, 0, -1, BFD_RELOC_SPU_IMM7
}, /* A_U7 */
217 { 14, 0, 0, 0, 16383, 0, -1, 0 }, /* A_U14 */
218 { 16, 7, 0, -32768, 65535, 0, -1, BFD_RELOC_SPU_IMM16
}, /* A_X16 */
219 { 18, 7, 0, 0, 262143, 0, -1, BFD_RELOC_SPU_IMM18
}, /* A_U18 */
222 /* Some flags for handling errors. This is very hackish and added after
224 static int syntax_error_arg
;
225 static const char *syntax_error_param
;
226 static int syntax_reg
;
229 insn_fmt_string (struct spu_opcode
*format
)
235 len
+= sprintf (&buf
[len
], "%s\t", format
->mnemonic
);
236 for (i
= 1; i
<= format
->arg
[0]; i
++)
238 int arg
= format
->arg
[i
];
240 if (i
> 1 && arg
!= A_P
&& format
->arg
[i
-1] != A_P
)
245 exp
= i
== syntax_error_arg
? "REG" : "reg";
247 exp
= i
== syntax_error_arg
? "IMM" : "imm";
248 len
+= sprintf (&buf
[len
], "%s", exp
);
249 if (i
> 1 && format
->arg
[i
-1] == A_P
)
257 md_assemble (char *op
)
259 char *param
, *thisfrag
;
261 struct spu_opcode
*format
;
262 struct spu_insn insn
;
267 /* skip over instruction to find parameters */
269 for (param
= op
; *param
!= 0 && !ISSPACE (*param
); param
++)
274 if (c
!= 0 && c
!= '\n')
277 /* try to find the instruction in the hash table */
279 if ((format
= (struct spu_opcode
*) hash_find (op_hash
, op
)) == NULL
)
281 as_bad (_("Invalid mnemonic '%s'"), op
);
285 if (!use_dd2
&& strcmp (format
->mnemonic
, "orx") == 0)
287 as_bad (_("'%s' is only available in DD2.0 or higher."), op
);
293 /* try parsing this instruction into insn */
294 for (i
= 0; i
< MAX_RELOCS
; i
++)
296 insn
.exp
[i
].X_add_symbol
= 0;
297 insn
.exp
[i
].X_op_symbol
= 0;
298 insn
.exp
[i
].X_add_number
= 0;
299 insn
.exp
[i
].X_op
= O_illegal
;
300 insn
.reloc_arg
[i
] = -1;
303 insn
.opcode
= format
->opcode
;
304 insn
.tag
= (enum spu_insns
) (format
- spu_opcodes
);
306 syntax_error_arg
= 0;
307 syntax_error_param
= 0;
309 if (calcop (format
, param
, &insn
))
312 /* if it doesn't parse try the next instruction */
313 if (!strcmp (format
[0].mnemonic
, format
[1].mnemonic
))
317 int parg
= format
[0].arg
[syntax_error_arg
-1];
319 as_fatal (_("Error in argument %d. Expecting: \"%s\""),
320 syntax_error_arg
- (parg
== A_P
),
321 insn_fmt_string (format
));
327 && ! (insn
.tag
== M_RDCH
328 || insn
.tag
== M_RCHCNT
329 || insn
.tag
== M_WRCH
))
330 as_warn (_("Mixing register syntax, with and without '$'."));
331 if (syntax_error_param
)
333 const char *d
= syntax_error_param
;
336 as_warn (_("Treating '%-*s' as a symbol."), syntax_error_param
- d
, d
);
339 /* grow the current frag and plop in the opcode */
341 thisfrag
= frag_more (4);
342 md_number_to_chars (thisfrag
, insn
.opcode
, 4);
344 /* if this instruction requires labels mark it for later */
346 for (i
= 0; i
< MAX_RELOCS
; i
++)
347 if (insn
.reloc_arg
[i
] >= 0)
350 bfd_reloc_code_real_type reloc
= arg_encode
[insn
.reloc_arg
[i
]].reloc
;
352 if (reloc
== BFD_RELOC_SPU_PCREL9a
353 || reloc
== BFD_RELOC_SPU_PCREL9b
354 || reloc
== BFD_RELOC_SPU_PCREL16
)
356 if (insn
.flag
[i
] & 1)
357 reloc
= BFD_RELOC_SPU_HI16
;
358 else if (insn
.flag
[i
] & 2)
359 reloc
= BFD_RELOC_SPU_LO16
;
360 fixP
= fix_new_exp (frag_now
,
361 thisfrag
- frag_now
->fr_literal
,
366 fixP
->tc_fix_data
= insn
.reloc_arg
[i
];
368 dwarf2_emit_insn (4);
372 calcop (struct spu_opcode
*format
, const char *param
, struct spu_insn
*insn
)
378 for (i
= 1; i
<= format
->arg
[0]; i
++)
380 arg
= format
->arg
[i
];
381 syntax_error_arg
= i
;
383 while (ISSPACE (*param
))
385 if (*param
== 0 || *param
== ',')
388 param
= get_reg (param
, insn
, arg
, 1);
390 param
= get_imm (param
, insn
, arg
);
401 while (ISSPACE (*param
))
404 if (arg
!= A_P
&& paren
)
410 else if (i
< format
->arg
[0]
411 && format
->arg
[i
] != A_P
412 && format
->arg
[i
+1] != A_P
)
421 while (ISSPACE (*param
))
423 return !paren
&& (*param
== 0 || *param
== '\n');
432 #define REG_NAME(NO,NM) { NO, sizeof (NM) - 1, NM }
434 static struct reg_name reg_name
[] = {
435 REG_NAME (0, "lr"), /* link register */
436 REG_NAME (1, "sp"), /* stack pointer */
437 REG_NAME (0, "rp"), /* link register */
438 REG_NAME (127, "fp"), /* frame pointer */
441 static struct reg_name sp_reg_name
[] = {
444 static struct reg_name ch_reg_name
[] = {
445 REG_NAME ( 0, "SPU_RdEventStat"),
446 REG_NAME ( 1, "SPU_WrEventMask"),
447 REG_NAME ( 2, "SPU_WrEventAck"),
448 REG_NAME ( 3, "SPU_RdSigNotify1"),
449 REG_NAME ( 4, "SPU_RdSigNotify2"),
450 REG_NAME ( 7, "SPU_WrDec"),
451 REG_NAME ( 8, "SPU_RdDec"),
452 REG_NAME ( 11, "SPU_RdEventMask"), /* DD2.0 only */
453 REG_NAME ( 13, "SPU_RdMachStat"),
454 REG_NAME ( 14, "SPU_WrSRR0"),
455 REG_NAME ( 15, "SPU_RdSRR0"),
456 REG_NAME ( 28, "SPU_WrOutMbox"),
457 REG_NAME ( 29, "SPU_RdInMbox"),
458 REG_NAME ( 30, "SPU_WrOutIntrMbox"),
459 REG_NAME ( 9, "MFC_WrMSSyncReq"),
460 REG_NAME ( 12, "MFC_RdTagMask"), /* DD2.0 only */
461 REG_NAME ( 16, "MFC_LSA"),
462 REG_NAME ( 17, "MFC_EAH"),
463 REG_NAME ( 18, "MFC_EAL"),
464 REG_NAME ( 19, "MFC_Size"),
465 REG_NAME ( 20, "MFC_TagID"),
466 REG_NAME ( 21, "MFC_Cmd"),
467 REG_NAME ( 22, "MFC_WrTagMask"),
468 REG_NAME ( 23, "MFC_WrTagUpdate"),
469 REG_NAME ( 24, "MFC_RdTagStat"),
470 REG_NAME ( 25, "MFC_RdListStallStat"),
471 REG_NAME ( 26, "MFC_WrListStallAck"),
472 REG_NAME ( 27, "MFC_RdAtomicStat"),
477 get_reg (const char *param
, struct spu_insn
*insn
, int arg
, int accept_expr
)
488 if (arg
== A_H
) /* Channel */
490 if ((param
[0] == 'c' || param
[0] == 'C')
491 && (param
[1] == 'h' || param
[1] == 'H')
492 && ISDIGIT (param
[2]))
495 else if (arg
== A_S
) /* Special purpose register */
497 if ((param
[0] == 's' || param
[0] == 'S')
498 && (param
[1] == 'p' || param
[1] == 'P')
499 && ISDIGIT (param
[2]))
503 if (ISDIGIT (*param
))
506 while (ISDIGIT (*param
))
507 regno
= regno
* 10 + *param
++ - '0';
512 unsigned int i
, n
, l
= 0;
514 if (arg
== A_H
) /* Channel */
517 n
= sizeof (ch_reg_name
) / sizeof (*ch_reg_name
);
519 else if (arg
== A_S
) /* Special purpose register */
522 n
= sizeof (sp_reg_name
) / sizeof (*sp_reg_name
);
527 n
= sizeof (reg_name
) / sizeof (*reg_name
);
530 for (i
= 0; i
< n
; i
++)
532 && 0 == strncasecmp (param
, rn
[i
].name
, rn
[i
].length
))
544 as_bad (_("'SPU_RdEventMask' (channel 11) is only available in DD2.0 or higher."));
545 else if (regno
== 12)
546 as_bad (_("'MFC_RdTagMask' (channel 12) is only available in DD2.0 or higher."));
551 insn
->opcode
|= regno
<< arg_encode
[arg
].pos
;
552 if ((!saw_prefix
&& syntax_reg
== 1)
553 || (saw_prefix
&& syntax_reg
== 2))
555 syntax_reg
|= saw_prefix
? 1 : 2;
563 save_ptr
= input_line_pointer
;
564 input_line_pointer
= (char *)param
;
566 param
= input_line_pointer
;
567 input_line_pointer
= save_ptr
;
568 if (ex
.X_op
== O_register
|| ex
.X_op
== O_constant
)
570 insn
->opcode
|= ex
.X_add_number
<< arg_encode
[arg
].pos
;
578 get_imm (const char *param
, struct spu_insn
*insn
, int arg
)
582 int low
= 0, high
= 0;
583 int reloc_i
= insn
->reloc_arg
[0] >= 0 ? 1 : 0;
585 if (strncmp (param
, "%lo(", 4) == 0)
589 as_warn (_("Using old style, %%lo(expr), please change to PPC style, expr@l."));
591 else if (strncmp (param
, "%hi(", 4) == 0)
595 as_warn (_("Using old style, %%hi(expr), please change to PPC style, expr@h."));
597 else if (strncmp (param
, "%pic(", 5) == 0)
599 /* Currently we expect %pic(expr) == expr, so do nothing here.
600 * i.e. for code loaded at address 0 $toc will be 0. */
606 /* Symbols can start with $, but if this symbol matches a register
607 * name, it's probably a mistake. The only way to avoid this
608 * warning is to rename the symbol. */
609 struct spu_insn tmp_insn
;
610 const char *np
= get_reg (param
, &tmp_insn
, arg
, 0);
613 syntax_error_param
= np
;
616 save_ptr
= input_line_pointer
;
617 input_line_pointer
= (char *) param
;
618 expression (&insn
->exp
[reloc_i
]);
619 param
= input_line_pointer
;
620 input_line_pointer
= save_ptr
;
622 /* Similar to ppc_elf_suffix in tc-ppc.c. We have so few cases to
623 * handle we do it inlined here. */
624 if (param
[0] == '@' && !ISALNUM (param
[2]) && param
[2] != '@')
626 if (param
[1] == 'h' || param
[1] == 'H')
631 else if (param
[1] == 'l' || param
[1] == 'L')
638 val
= insn
->exp
[reloc_i
].X_add_number
;
640 if (insn
->exp
[reloc_i
].X_op
== O_constant
)
644 /* Convert the value to a format we expect. */
645 val
<<= arg_encode
[arg
].rshift
;
648 else if (arg
== A_U7B
)
657 /* Warn about out of range expressions. */
659 int hi
= arg_encode
[arg
].hi
;
660 int lo
= arg_encode
[arg
].lo
;
661 int whi
= arg_encode
[arg
].whi
;
662 int wlo
= arg_encode
[arg
].wlo
;
664 if (hi
> lo
&& (val
< lo
|| val
> hi
))
665 as_fatal (_("Constant expression %d out of range, [%d, %d]."),
667 else if (whi
> wlo
&& (val
< wlo
|| val
> whi
))
668 as_warn (_("Constant expression %d out of range, [%d, %d]."),
674 else if (arg
== A_U7B
)
677 /* Branch hints have a split encoding. Do the bottom part. */
678 if (arg
== A_S11
|| arg
== A_S11I
)
679 insn
->opcode
|= ((val
>> 2) & 0x7f);
681 insn
->opcode
|= (((val
>> arg_encode
[arg
].rshift
)
682 & ((1 << arg_encode
[arg
].size
) - 1))
683 << arg_encode
[arg
].pos
);
684 insn
->reloc_arg
[reloc_i
] = -1;
685 insn
->flag
[reloc_i
] = 0;
689 insn
->reloc_arg
[reloc_i
] = arg
;
691 insn
->flag
[reloc_i
] |= 1;
693 insn
->flag
[reloc_i
] |= 2;
699 #define MAX_LITTLENUMS 6
701 /* Turn a string in input_line_pointer into a floating point constant of type
702 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
703 emitted is stored in *sizeP . An error message is returned, or NULL on OK.
706 md_atof (int type
, char *litP
, int *sizeP
)
709 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
710 LITTLENUM_TYPE
*wordP
;
741 return _("Bad call to MD_ATOF()");
743 t
= atof_ieee (input_line_pointer
, type
, words
);
745 input_line_pointer
= t
;
747 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
748 for (wordP
= words
; prec
--;)
750 md_number_to_chars (litP
, (long) (*wordP
++), sizeof (LITTLENUM_TYPE
));
751 litP
+= sizeof (LITTLENUM_TYPE
);
756 #ifndef WORKING_DOT_WORD
757 int md_short_jump_size
= 4;
760 md_create_short_jump (char *ptr
,
761 addressT from_addr ATTRIBUTE_UNUSED
,
762 addressT to_addr ATTRIBUTE_UNUSED
,
766 ptr
[0] = (char) 0xc0;
771 ptr
- frag
->fr_literal
,
776 BFD_RELOC_SPU_PCREL16
);
779 int md_long_jump_size
= 4;
782 md_create_long_jump (char *ptr
,
783 addressT from_addr ATTRIBUTE_UNUSED
,
784 addressT to_addr ATTRIBUTE_UNUSED
,
788 ptr
[0] = (char) 0xc0;
793 ptr
- frag
->fr_literal
,
798 BFD_RELOC_SPU_PCREL16
);
803 md_estimate_size_before_relax (fragS
*fragP ATTRIBUTE_UNUSED
,
804 segT segment_type ATTRIBUTE_UNUSED
)
806 as_fatal (_("Relaxation should never occur"));
810 /* If while processing a fixup, a reloc really needs to be created,
811 then it is done here. */
814 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
817 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
818 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
820 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
821 else if (fixp
->fx_subsy
)
822 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_subsy
);
823 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
824 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
825 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
827 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
828 _("reloc %d not supported by object file format"),
829 (int) fixp
->fx_r_type
);
832 reloc
->addend
= fixp
->fx_addnumber
;
836 /* Round up a section's size to the appropriate boundary. */
839 md_section_align (segT seg
, valueT size
)
841 int align
= bfd_get_section_alignment (stdoutput
, seg
);
842 valueT mask
= ((valueT
) 1 << align
) - 1;
844 return (size
+ mask
) & ~mask
;
847 /* Where a PC relative offset is calculated from. On the spu they
848 are calculated from the beginning of the branch instruction. */
851 md_pcrel_from (fixS
*fixp
)
853 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
856 /* Fill in rs_align_code fragments. */
859 spu_handle_align (fragS
*fragp
)
861 static const unsigned char nop_pattern
[8] = {
862 0x40, 0x20, 0x00, 0x00, /* even nop */
863 0x00, 0x20, 0x00, 0x00, /* odd nop */
869 if (fragp
->fr_type
!= rs_align_code
)
872 bytes
= fragp
->fr_next
->fr_address
- fragp
->fr_address
- fragp
->fr_fix
;
873 p
= fragp
->fr_literal
+ fragp
->fr_fix
;
881 fragp
->fr_fix
+= fix
;
885 memcpy (p
, &nop_pattern
[4], 4);
891 memcpy (p
, nop_pattern
, 8);
896 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
900 char *place
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
902 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
904 /* We can't actually support subtracting a symbol. */
905 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
908 if (fixP
->fx_addsy
!= NULL
)
912 /* Hack around bfd_install_relocation brain damage. */
913 val
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
915 switch (fixP
->fx_r_type
)
918 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
921 case BFD_RELOC_SPU_PCREL16
:
922 case BFD_RELOC_SPU_PCREL9a
:
923 case BFD_RELOC_SPU_PCREL9b
:
924 case BFD_RELOC_32_PCREL
:
928 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
929 _("expression too complex"));
935 fixP
->fx_addnumber
= val
;
937 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
941 if (fixP
->tc_fix_data
> A_P
)
943 int hi
= arg_encode
[fixP
->tc_fix_data
].hi
;
944 int lo
= arg_encode
[fixP
->tc_fix_data
].lo
;
945 if (hi
> lo
&& ((offsetT
) val
< lo
|| (offsetT
) val
> hi
))
946 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
947 "Relocation doesn't fit. (relocation value = 0x%lx)",
951 switch (fixP
->fx_r_type
)
954 md_number_to_chars (place
, val
, 1);
958 md_number_to_chars (place
, val
, 2);
962 md_number_to_chars (place
, val
, 4);
966 md_number_to_chars (place
, val
, 8);
969 case BFD_RELOC_SPU_IMM7
:
970 res
= (val
& 0x7f) << 14;
973 case BFD_RELOC_SPU_IMM8
:
974 res
= (val
& 0xff) << 14;
977 case BFD_RELOC_SPU_IMM10
:
978 res
= (val
& 0x3ff) << 14;
981 case BFD_RELOC_SPU_IMM10W
:
982 res
= (val
& 0x3ff0) << 10;
985 case BFD_RELOC_SPU_IMM16
:
986 res
= (val
& 0xffff) << 7;
989 case BFD_RELOC_SPU_IMM16W
:
990 res
= (val
& 0x3fffc) << 5;
993 case BFD_RELOC_SPU_IMM18
:
994 res
= (val
& 0x3ffff) << 7;
997 case BFD_RELOC_SPU_PCREL9a
:
998 res
= ((val
& 0x1fc) >> 2) | ((val
& 0x600) << 14);
1001 case BFD_RELOC_SPU_PCREL9b
:
1002 res
= ((val
& 0x1fc) >> 2) | ((val
& 0x600) << 5);
1005 case BFD_RELOC_SPU_PCREL16
:
1006 res
= (val
& 0x3fffc) << 5;
1010 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1011 _("reloc %d not supported by object file format"),
1012 (int) fixP
->fx_r_type
);
1017 place
[0] |= (res
>> 24) & 0xff;
1018 place
[1] |= (res
>> 16) & 0xff;
1019 place
[2] |= (res
>> 8) & 0xff;
1020 place
[3] |= (res
) & 0xff;