1 /* tc-tilegx.c -- Assemble for a Tile-Gx chip.
2 Copyright (C) 2011-2019 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
24 #include "elf/tilegx.h"
25 #include "opcode/tilegx.h"
27 #include "dwarf2dbg.h"
28 #include "dw2gencfi.h"
30 #include "safe-ctype.h"
33 /* Special registers. */
43 /* Generic assembler global variables which must be defined by all
46 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
47 int tilegx_cie_data_alignment
;
49 /* Characters which always start a comment. */
50 const char comment_chars
[] = "#";
52 /* Characters which start a comment at the beginning of a line. */
53 const char line_comment_chars
[] = "#";
55 /* Characters which may be used to separate multiple commands on a
57 const char line_separator_chars
[] = ";";
59 /* Characters which are used to indicate an exponent in a floating
61 const char EXP_CHARS
[] = "eE";
63 /* Characters which mean that a number is a floating point constant,
65 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
67 /* Either 32 or 64. */
68 static int tilegx_arch_size
= 64;
72 tilegx_target_format (void)
74 if (target_big_endian
) {
75 return tilegx_arch_size
== 64 ? "elf64-tilegx-be" : "elf32-tilegx-be";
77 return tilegx_arch_size
== 64 ? "elf64-tilegx-le" : "elf32-tilegx-le";
82 #define OPTION_32 (OPTION_MD_BASE + 0)
83 #define OPTION_64 (OPTION_MD_BASE + 1)
84 #define OPTION_EB (OPTION_MD_BASE + 2)
85 #define OPTION_EL (OPTION_MD_BASE + 3)
87 const char *md_shortopts
= "VQ:";
89 struct option md_longopts
[] =
91 {"32", no_argument
, NULL
, OPTION_32
},
92 {"64", no_argument
, NULL
, OPTION_64
},
93 {"EB", no_argument
, NULL
, OPTION_EB
},
94 {"EL", no_argument
, NULL
, OPTION_EL
},
95 {NULL
, no_argument
, NULL
, 0}
98 size_t md_longopts_size
= sizeof (md_longopts
);
101 md_parse_option (int c
, const char *arg ATTRIBUTE_UNUSED
)
105 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
106 should be emitted or not. FIXME: Not implemented. */
110 /* -V: SVR4 argument to print version ID. */
116 tilegx_arch_size
= 32;
120 tilegx_arch_size
= 64;
124 target_big_endian
= 1;
128 target_big_endian
= 0;
139 md_show_usage (FILE *stream
)
141 fprintf (stream
, _("\
143 -V print assembler version number\n\
144 -EB/-EL generate big-endian/little-endian code\n\
145 --32/--64 generate 32bit/64bit code\n"));
149 /* Extra expression types. */
155 #define O_hw0_last O_md5
156 #define O_hw1_last O_md6
157 #define O_hw2_last O_md7
158 #define O_hw0_got O_md8
159 #define O_hw0_last_got O_md9
160 #define O_hw1_last_got O_md10
162 #define O_hw0_tls_gd O_md12
163 #define O_hw0_last_tls_gd O_md13
164 #define O_hw1_last_tls_gd O_md14
165 #define O_hw0_tls_ie O_md15
166 #define O_hw0_last_tls_ie O_md16
167 #define O_hw1_last_tls_ie O_md17
168 #define O_hw0_tls_le O_md18
169 #define O_hw0_last_tls_le O_md19
170 #define O_hw1_last_tls_le O_md20
171 #define O_tls_gd_call O_md21
172 #define O_tls_gd_add O_md22
173 #define O_tls_ie_load O_md23
174 #define O_tls_add O_md24
175 #define O_hw0_plt O_md25
176 #define O_hw1_plt O_md26
177 #define O_hw1_last_plt O_md27
178 #define O_hw2_last_plt O_md28
180 static struct hash_control
*special_operator_hash
;
182 /* Hash tables for instruction mnemonic lookup. */
183 static struct hash_control
*op_hash
;
185 /* Hash table for spr lookup. */
186 static struct hash_control
*spr_hash
;
188 /* True temporarily while parsing an SPR expression. This changes the
189 * namespace to include SPR names. */
190 static int parsing_spr
;
192 /* Are we currently inside `{ ... }'? */
193 static int inside_bundle
;
195 struct tilegx_instruction
197 const struct tilegx_opcode
*opcode
;
198 tilegx_pipeline pipe
;
199 expressionS operand_values
[TILEGX_MAX_OPERANDS
];
202 /* This keeps track of the current bundle being built up. */
203 static struct tilegx_instruction current_bundle
[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE
];
205 /* Index in current_bundle for the next instruction to parse. */
206 static int current_bundle_index
;
208 /* Allow 'r63' in addition to 'zero', etc. Normally we disallow this as
209 'zero' is not a real register, so using it accidentally would be a
210 nasty bug. For other registers, such as 'sp', code using multiple names
211 for the same physical register is excessively confusing.
213 The '.require_canonical_reg_names' pseudo-op turns this error on,
214 and the '.no_require_canonical_reg_names' pseudo-op turns this off.
215 By default the error is on. */
216 static int require_canonical_reg_names
;
218 /* Allow bundles that do undefined or suspicious things like write
219 two different values to the same register at the same time.
221 The '.no_allow_suspicious_bundles' pseudo-op turns this error on,
222 and the '.allow_suspicious_bundles' pseudo-op turns this off. */
223 static int allow_suspicious_bundles
;
226 /* A hash table of main processor registers, mapping each register name
229 Furthermore, if the register number is greater than the number
230 of registers for that processor, the user used an illegal alias
231 for that register (e.g. r63 instead of zero), so we should generate
232 a warning. The attempted register number can be found by clearing
233 NONCANONICAL_REG_NAME_FLAG. */
234 static struct hash_control
*main_reg_hash
;
237 /* We cannot unambiguously store a 0 in a hash table and look it up,
238 so we OR in this flag to every canonical register. */
239 #define CANONICAL_REG_NAME_FLAG 0x1000
241 /* By default we disallow register aliases like r63, but we record
242 them in the hash table in case the .no_require_canonical_reg_names
243 directive is used. Noncanonical names have this value added to them. */
244 #define NONCANONICAL_REG_NAME_FLAG 0x2000
246 /* Discards flags for register hash table entries and returns the
248 #define EXTRACT_REGNO(p) ((p) & 63)
250 /* This function is called once, at assembler startup time. It should
251 set up all the tables, etc., that the MD part of the assembler will
257 const struct tilegx_opcode
*op
;
259 int mach
= (tilegx_arch_size
== 64) ? bfd_mach_tilegx
: bfd_mach_tilegx32
;
261 if (! bfd_set_arch_mach (stdoutput
, bfd_arch_tilegx
, mach
))
262 as_warn (_("Could not set architecture and machine"));
264 /* Guarantee text section is aligned. */
265 bfd_set_section_alignment (stdoutput
, text_section
,
266 TILEGX_LOG2_BUNDLE_ALIGNMENT_IN_BYTES
);
268 require_canonical_reg_names
= 1;
269 allow_suspicious_bundles
= 0;
270 current_bundle_index
= 0;
273 tilegx_cie_data_alignment
= (tilegx_arch_size
== 64 ? -8 : -4);
275 /* Initialize special operator hash table. */
276 special_operator_hash
= hash_new ();
277 #define INSERT_SPECIAL_OP(name) \
278 hash_insert (special_operator_hash, #name, (void *)O_##name)
280 INSERT_SPECIAL_OP (hw0
);
281 INSERT_SPECIAL_OP (hw1
);
282 INSERT_SPECIAL_OP (hw2
);
283 INSERT_SPECIAL_OP (hw3
);
284 INSERT_SPECIAL_OP (hw0_last
);
285 INSERT_SPECIAL_OP (hw1_last
);
286 INSERT_SPECIAL_OP (hw2_last
);
287 /* hw3_last is a convenience alias for the equivalent hw3. */
288 hash_insert (special_operator_hash
, "hw3_last", (void*)O_hw3
);
289 INSERT_SPECIAL_OP (hw0_got
);
290 INSERT_SPECIAL_OP (hw0_last_got
);
291 INSERT_SPECIAL_OP (hw1_last_got
);
292 INSERT_SPECIAL_OP(plt
);
293 INSERT_SPECIAL_OP (hw0_tls_gd
);
294 INSERT_SPECIAL_OP (hw0_last_tls_gd
);
295 INSERT_SPECIAL_OP (hw1_last_tls_gd
);
296 INSERT_SPECIAL_OP (hw0_tls_ie
);
297 INSERT_SPECIAL_OP (hw0_last_tls_ie
);
298 INSERT_SPECIAL_OP (hw1_last_tls_ie
);
299 INSERT_SPECIAL_OP (hw0_tls_le
);
300 INSERT_SPECIAL_OP (hw0_last_tls_le
);
301 INSERT_SPECIAL_OP (hw1_last_tls_le
);
302 INSERT_SPECIAL_OP (tls_gd_call
);
303 INSERT_SPECIAL_OP (tls_gd_add
);
304 INSERT_SPECIAL_OP (tls_ie_load
);
305 INSERT_SPECIAL_OP (tls_add
);
306 INSERT_SPECIAL_OP (hw0_plt
);
307 INSERT_SPECIAL_OP (hw1_plt
);
308 INSERT_SPECIAL_OP (hw1_last_plt
);
309 INSERT_SPECIAL_OP (hw2_last_plt
);
310 #undef INSERT_SPECIAL_OP
312 /* Initialize op_hash hash table. */
313 op_hash
= hash_new ();
314 for (op
= &tilegx_opcodes
[0]; op
->name
!= NULL
; op
++)
316 const char *hash_err
= hash_insert (op_hash
, op
->name
, (void *)op
);
317 if (hash_err
!= NULL
)
318 as_fatal (_("Internal Error: Can't hash %s: %s"), op
->name
, hash_err
);
321 /* Initialize the spr hash table. */
323 spr_hash
= hash_new ();
324 for (i
= 0; i
< tilegx_num_sprs
; i
++)
325 hash_insert (spr_hash
, tilegx_sprs
[i
].name
,
326 (void *) &tilegx_sprs
[i
]);
328 /* Set up the main_reg_hash table. We use this instead of
329 creating a symbol in the register section to avoid ambiguities
330 with labels that have the same names as registers. */
331 main_reg_hash
= hash_new ();
332 for (i
= 0; i
< TILEGX_NUM_REGISTERS
; i
++)
336 hash_insert (main_reg_hash
, tilegx_register_names
[i
],
337 (void *) (long) (i
| CANONICAL_REG_NAME_FLAG
));
339 /* See if we should insert a noncanonical alias, like r63. */
340 sprintf (buf
, "r%d", i
);
341 if (strcmp (buf
, tilegx_register_names
[i
]) != 0)
342 hash_insert (main_reg_hash
, xstrdup (buf
),
343 (void *) (long) (i
| NONCANONICAL_REG_NAME_FLAG
));
347 #define BUNDLE_TEMPLATE_MASK(p0, p1, p2) \
348 ((p0) | ((p1) << 8) | ((p2) << 16))
349 #define BUNDLE_TEMPLATE(p0, p1, p2) \
350 { { (p0), (p1), (p2) }, \
351 BUNDLE_TEMPLATE_MASK(1 << (p0), 1 << (p1), (1 << (p2))) \
354 #define NO_PIPELINE TILEGX_NUM_PIPELINE_ENCODINGS
356 struct bundle_template
358 tilegx_pipeline pipe
[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE
];
359 unsigned int pipe_mask
;
362 static const struct bundle_template bundle_templates
[] =
364 /* In Y format we must always have something in Y2, since it has
365 no fnop, so this conveys that Y2 must always be used. */
366 BUNDLE_TEMPLATE(TILEGX_PIPELINE_Y0
, TILEGX_PIPELINE_Y2
, NO_PIPELINE
),
367 BUNDLE_TEMPLATE(TILEGX_PIPELINE_Y1
, TILEGX_PIPELINE_Y2
, NO_PIPELINE
),
368 BUNDLE_TEMPLATE(TILEGX_PIPELINE_Y2
, TILEGX_PIPELINE_Y0
, NO_PIPELINE
),
369 BUNDLE_TEMPLATE(TILEGX_PIPELINE_Y2
, TILEGX_PIPELINE_Y1
, NO_PIPELINE
),
371 /* Y format has three instructions. */
372 BUNDLE_TEMPLATE(TILEGX_PIPELINE_Y0
,TILEGX_PIPELINE_Y1
,TILEGX_PIPELINE_Y2
),
373 BUNDLE_TEMPLATE(TILEGX_PIPELINE_Y0
,TILEGX_PIPELINE_Y2
,TILEGX_PIPELINE_Y1
),
374 BUNDLE_TEMPLATE(TILEGX_PIPELINE_Y1
,TILEGX_PIPELINE_Y0
,TILEGX_PIPELINE_Y2
),
375 BUNDLE_TEMPLATE(TILEGX_PIPELINE_Y1
,TILEGX_PIPELINE_Y2
,TILEGX_PIPELINE_Y0
),
376 BUNDLE_TEMPLATE(TILEGX_PIPELINE_Y2
,TILEGX_PIPELINE_Y0
,TILEGX_PIPELINE_Y1
),
377 BUNDLE_TEMPLATE(TILEGX_PIPELINE_Y2
,TILEGX_PIPELINE_Y1
,TILEGX_PIPELINE_Y0
),
379 /* X format has only two instructions. */
380 BUNDLE_TEMPLATE(TILEGX_PIPELINE_X0
, TILEGX_PIPELINE_X1
, NO_PIPELINE
),
381 BUNDLE_TEMPLATE(TILEGX_PIPELINE_X1
, TILEGX_PIPELINE_X0
, NO_PIPELINE
)
386 prepend_nop_to_bundle (tilegx_mnemonic mnemonic
)
388 memmove (¤t_bundle
[1], ¤t_bundle
[0],
389 current_bundle_index
* sizeof current_bundle
[0]);
390 current_bundle
[0].opcode
= &tilegx_opcodes
[mnemonic
];
391 ++current_bundle_index
;
394 static tilegx_bundle_bits
395 insert_operand (tilegx_bundle_bits bits
,
396 const struct tilegx_operand
*operand
,
401 /* Range-check the immediate. */
402 int num_bits
= operand
->num_bits
;
404 operand_value
>>= operand
->rightshift
;
406 if (bfd_check_overflow (operand
->is_signed
407 ? complain_overflow_signed
408 : complain_overflow_unsigned
,
411 bfd_arch_bits_per_address (stdoutput
),
416 if (operand
->is_signed
)
418 min
= -(1 << (num_bits
- 1));
419 max
= (1 << (num_bits
- 1)) - 1;
424 max
= (1 << num_bits
) - 1;
426 as_bad_value_out_of_range (_("operand"), operand_value
, min
, max
,
430 /* Write out the bits for the immediate. */
431 return bits
| operand
->insert (operand_value
);
436 apply_special_operator (operatorT op
, offsetT num
, const char *file
,
440 int check_shift
= -1;
448 ret
= (signed short)num
;
455 ret
= (signed short)(num
>> 16);
462 ret
= (signed short)(num
>> 32);
466 ret
= (signed short)(num
>> 48);
474 if (check_shift
>= 0 && ret
!= (num
>> check_shift
))
476 as_bad_value_out_of_range (_("operand"), num
,
477 ~0ULL << (check_shift
+ 16 - 1),
478 ~0ULL >> (64 - (check_shift
+ 16 - 1)),
485 static tilegx_bundle_bits
486 emit_tilegx_instruction (tilegx_bundle_bits bits
,
488 const unsigned char *operands
,
489 expressionS
*operand_values
,
494 for (i
= 0; i
< num_operands
; i
++)
496 const struct tilegx_operand
*operand
=
497 &tilegx_operands
[operands
[i
]];
498 expressionS
*operand_exp
= &operand_values
[i
];
499 int is_pc_relative
= operand
->is_pc_relative
;
501 if (operand_exp
->X_op
== O_register
502 || (operand_exp
->X_op
== O_constant
&& !is_pc_relative
))
504 /* We know what the bits are right now, so insert them. */
505 bits
= insert_operand (bits
, operand
, operand_exp
->X_add_number
,
510 bfd_reloc_code_real_type reloc
= operand
->default_reloc
;
512 int die
= 0, use_subexp
= 0, require_symbol
= 0;
515 /* Take an expression like hw0(x) and turn it into x with
516 a different reloc type. */
517 switch (operand_exp
->X_op
)
519 #define HANDLE_OP16(suffix) \
522 case BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST: \
523 reloc = BFD_RELOC_TILEGX_IMM16_X0_##suffix; \
525 case BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST: \
526 reloc = BFD_RELOC_TILEGX_IMM16_X1_##suffix; \
551 HANDLE_OP16 (HW0_LAST
);
555 HANDLE_OP16 (HW1_LAST
);
559 HANDLE_OP16 (HW2_LAST
);
563 HANDLE_OP16 (HW0_GOT
);
568 HANDLE_OP16 (HW0_LAST_GOT
);
573 HANDLE_OP16 (HW1_LAST_GOT
);
578 HANDLE_OP16 (HW0_TLS_GD
);
582 case O_hw0_last_tls_gd
:
583 HANDLE_OP16 (HW0_LAST_TLS_GD
);
587 case O_hw1_last_tls_gd
:
588 HANDLE_OP16 (HW1_LAST_TLS_GD
);
593 HANDLE_OP16 (HW0_TLS_IE
);
597 case O_hw0_last_tls_ie
:
598 HANDLE_OP16 (HW0_LAST_TLS_IE
);
602 case O_hw1_last_tls_ie
:
603 HANDLE_OP16 (HW1_LAST_TLS_IE
);
608 HANDLE_OP16 (HW0_TLS_LE
);
612 case O_hw0_last_tls_le
:
613 HANDLE_OP16 (HW0_LAST_TLS_LE
);
617 case O_hw1_last_tls_le
:
618 HANDLE_OP16 (HW1_LAST_TLS_LE
);
623 HANDLE_OP16 (HW0_PLT_PCREL
);
627 HANDLE_OP16 (HW1_PLT_PCREL
);
631 HANDLE_OP16 (HW1_LAST_PLT_PCREL
);
635 HANDLE_OP16 (HW2_LAST_PLT_PCREL
);
643 case BFD_RELOC_TILEGX_JUMPOFF_X1
:
644 reloc
= BFD_RELOC_TILEGX_JUMPOFF_X1_PLT
;
657 case BFD_RELOC_TILEGX_JUMPOFF_X1
:
658 reloc
= BFD_RELOC_TILEGX_TLS_GD_CALL
;
671 case BFD_RELOC_TILEGX_IMM8_X0
:
672 reloc
= BFD_RELOC_TILEGX_IMM8_X0_TLS_GD_ADD
;
674 case BFD_RELOC_TILEGX_IMM8_X1
:
675 reloc
= BFD_RELOC_TILEGX_IMM8_X1_TLS_GD_ADD
;
677 case BFD_RELOC_TILEGX_IMM8_Y0
:
678 reloc
= BFD_RELOC_TILEGX_IMM8_Y0_TLS_GD_ADD
;
680 case BFD_RELOC_TILEGX_IMM8_Y1
:
681 reloc
= BFD_RELOC_TILEGX_IMM8_Y1_TLS_GD_ADD
;
694 case BFD_RELOC_TILEGX_IMM8_X1
:
695 reloc
= BFD_RELOC_TILEGX_TLS_IE_LOAD
;
708 case BFD_RELOC_TILEGX_IMM8_X0
:
709 reloc
= BFD_RELOC_TILEGX_IMM8_X0_TLS_ADD
;
711 case BFD_RELOC_TILEGX_IMM8_X1
:
712 reloc
= BFD_RELOC_TILEGX_IMM8_X1_TLS_ADD
;
714 case BFD_RELOC_TILEGX_IMM8_Y0
:
715 reloc
= BFD_RELOC_TILEGX_IMM8_Y0_TLS_ADD
;
717 case BFD_RELOC_TILEGX_IMM8_Y1
:
718 reloc
= BFD_RELOC_TILEGX_IMM8_Y1_TLS_ADD
;
735 as_bad (_("Invalid operator for operand."));
739 expressionS
*sval
= NULL
;
740 /* Now that we've changed the reloc, change ha16(x) into x,
743 if (symbol_symbolS (operand_exp
->X_add_symbol
))
744 sval
= symbol_get_value_expression (operand_exp
->X_add_symbol
);
745 if (sval
&& sval
->X_md
)
747 /* HACK: We used X_md to mark this symbol as a fake wrapper
748 around a real expression. To unwrap it, we just grab its
754 /* Look at the expression, and reject it if it's not a
756 if (operand_exp
->X_op
!= O_symbol
757 || operand_exp
->X_add_number
!= 0)
758 as_bad (_("Operator may only be applied to symbols."));
763 /* The value of this expression is an actual symbol, so
764 turn that into an expression. */
765 memset (&subexp
, 0, sizeof subexp
);
766 subexp
.X_op
= O_symbol
;
767 subexp
.X_add_symbol
= operand_exp
->X_add_symbol
;
768 operand_exp
= &subexp
;
772 /* Create a fixup to handle this later. */
773 fixP
= fix_new_exp (frag_now
,
774 bundle_start
- frag_now
->fr_literal
,
775 (operand
->num_bits
+ 7) >> 3,
779 fixP
->tc_fix_data
= operand
;
781 /* Don't do overflow checking if we are applying a function like
783 fixP
->fx_no_overflow
|= use_subexp
;
790 /* Detects and complains if two instructions in current_bundle write
791 to the same register, either implicitly or explicitly, or if a
792 read-only register is written. */
794 check_illegal_reg_writes (void)
796 BFD_HOST_U_64_BIT all_regs_written
= 0;
799 for (j
= 0; j
< current_bundle_index
; j
++)
801 const struct tilegx_instruction
*instr
= ¤t_bundle
[j
];
803 BFD_HOST_U_64_BIT regs
=
804 ((BFD_HOST_U_64_BIT
)1) << instr
->opcode
->implicitly_written_register
;
805 BFD_HOST_U_64_BIT conflict
;
807 for (k
= 0; k
< instr
->opcode
->num_operands
; k
++)
809 const struct tilegx_operand
*operand
=
810 &tilegx_operands
[instr
->opcode
->operands
[instr
->pipe
][k
]];
812 if (operand
->is_dest_reg
)
814 int regno
= instr
->operand_values
[k
].X_add_number
;
815 BFD_HOST_U_64_BIT mask
= ((BFD_HOST_U_64_BIT
)1) << regno
;
817 if ((mask
& ( (((BFD_HOST_U_64_BIT
)1) << TREG_IDN1
)
818 | (((BFD_HOST_U_64_BIT
)1) << TREG_UDN1
)
819 | (((BFD_HOST_U_64_BIT
)1) << TREG_UDN2
)
820 | (((BFD_HOST_U_64_BIT
)1) << TREG_UDN3
))) != 0
821 && !allow_suspicious_bundles
)
823 as_bad (_("Writes to register '%s' are not allowed."),
824 tilegx_register_names
[regno
]);
831 /* Writing to the zero register doesn't count. */
832 regs
&= ~(((BFD_HOST_U_64_BIT
)1) << TREG_ZERO
);
834 conflict
= all_regs_written
& regs
;
835 if (conflict
!= 0 && !allow_suspicious_bundles
)
837 /* Find which register caused the conflict. */
838 const char *conflicting_reg_name
= "???";
841 for (i
= 0; i
< TILEGX_NUM_REGISTERS
; i
++)
843 if (((conflict
>> i
) & 1) != 0)
845 conflicting_reg_name
= tilegx_register_names
[i
];
850 as_bad (_("Two instructions in the same bundle both write "
851 "to register %s, which is not allowed."),
852 conflicting_reg_name
);
855 all_regs_written
|= regs
;
861 tilegx_flush_bundle (void)
866 unsigned compatible_pipes
;
867 const struct bundle_template
*match
;
872 switch (current_bundle_index
)
875 /* No instructions. */
878 if (current_bundle
[0].opcode
->can_bundle
)
880 /* Simplify later logic by adding an explicit fnop. */
881 prepend_nop_to_bundle (TILEGX_OPC_FNOP
);
885 /* This instruction cannot be bundled with anything else.
886 Prepend an explicit 'nop', rather than an 'fnop', because
887 fnops can be replaced by later binary-processing tools while
889 prepend_nop_to_bundle (TILEGX_OPC_NOP
);
893 if (!allow_suspicious_bundles
)
895 /* Make sure all instructions can be bundled with other
897 const struct tilegx_opcode
*cannot_bundle
= NULL
;
898 bfd_boolean seen_non_nop
= FALSE
;
900 for (j
= 0; j
< current_bundle_index
; j
++)
902 const struct tilegx_opcode
*op
= current_bundle
[j
].opcode
;
904 if (!op
->can_bundle
&& cannot_bundle
== NULL
)
906 else if (op
->mnemonic
!= TILEGX_OPC_NOP
907 && op
->mnemonic
!= TILEGX_OPC_INFO
908 && op
->mnemonic
!= TILEGX_OPC_INFOL
)
912 if (cannot_bundle
!= NULL
&& seen_non_nop
)
914 current_bundle_index
= 0;
915 as_bad (_("'%s' may not be bundled with other instructions."),
916 cannot_bundle
->name
);
924 BUNDLE_TEMPLATE_MASK(current_bundle
[0].opcode
->pipes
,
925 current_bundle
[1].opcode
->pipes
,
926 (current_bundle_index
== 3
927 ? current_bundle
[2].opcode
->pipes
928 : (1 << NO_PIPELINE
)));
930 /* Find a template that works, if any. */
932 for (i
= 0; i
< sizeof bundle_templates
/ sizeof bundle_templates
[0]; i
++)
934 const struct bundle_template
*b
= &bundle_templates
[i
];
935 if ((b
->pipe_mask
& compatible_pipes
) == b
->pipe_mask
)
944 current_bundle_index
= 0;
945 as_bad (_("Invalid combination of instructions for bundle."));
949 /* If the section seems to have no alignment set yet, go ahead and
950 make it large enough to hold code. */
951 if (bfd_get_section_alignment (stdoutput
, now_seg
) == 0)
952 bfd_set_section_alignment (stdoutput
, now_seg
,
953 TILEGX_LOG2_BUNDLE_ALIGNMENT_IN_BYTES
);
955 for (j
= 0; j
< current_bundle_index
; j
++)
956 current_bundle
[j
].pipe
= match
->pipe
[j
];
958 if (current_bundle_index
== 2 && !tilegx_is_x_pipeline (match
->pipe
[0]))
960 /* We are in Y mode with only two instructions, so add an FNOP. */
961 prepend_nop_to_bundle (TILEGX_OPC_FNOP
);
963 /* Figure out what pipe the fnop must be in via arithmetic.
964 * p0 + p1 + p2 must sum to the sum of TILEGX_PIPELINE_Y[012]. */
965 current_bundle
[0].pipe
=
966 (tilegx_pipeline
)((TILEGX_PIPELINE_Y0
968 + TILEGX_PIPELINE_Y2
) -
969 (current_bundle
[1].pipe
+ current_bundle
[2].pipe
));
972 check_illegal_reg_writes ();
974 f
= frag_more (TILEGX_BUNDLE_SIZE_IN_BYTES
);
976 /* Check to see if this bundle is at an offset that is a multiple of 8-bytes
977 from the start of the frag. */
978 addr_mod
= frag_now_fix () & (TILEGX_BUNDLE_ALIGNMENT_IN_BYTES
- 1);
979 if (frag_now
->has_code
&& frag_now
->insn_addr
!= addr_mod
)
980 as_bad (_("instruction address is not a multiple of 8"));
981 frag_now
->insn_addr
= addr_mod
;
982 frag_now
->has_code
= 1;
984 tilegx_bundle_bits bits
= 0;
985 for (j
= 0; j
< current_bundle_index
; j
++)
987 struct tilegx_instruction
*instr
= ¤t_bundle
[j
];
988 tilegx_pipeline pipeline
= instr
->pipe
;
989 const struct tilegx_opcode
*opcode
= instr
->opcode
;
991 bits
|= emit_tilegx_instruction (opcode
->fixed_bit_values
[pipeline
],
992 opcode
->num_operands
,
993 &opcode
->operands
[pipeline
][0],
994 instr
->operand_values
,
998 number_to_chars_littleendian (f
, bits
, 8);
999 current_bundle_index
= 0;
1001 /* Emit DWARF2 debugging information. */
1002 dwarf2_emit_insn (TILEGX_BUNDLE_SIZE_IN_BYTES
);
1006 /* Extend the expression parser to handle hw0(label), etc.
1007 as well as SPR names when in the context of parsing an SPR. */
1010 tilegx_parse_name (char *name
, expressionS
*e
, char *nextcharP
)
1012 operatorT op
= O_illegal
;
1016 void* val
= hash_find (spr_hash
, name
);
1020 memset (e
, 0, sizeof *e
);
1021 e
->X_op
= O_constant
;
1022 e
->X_add_number
= ((const struct tilegx_spr
*)val
)->number
;
1026 if (*nextcharP
!= '(')
1028 /* hw0, etc. not followed by a paren is just a label with that name. */
1033 /* Look up the operator in our table. */
1034 void* val
= hash_find (special_operator_hash
, name
);
1037 op
= (operatorT
)(long)val
;
1040 /* Restore old '(' and skip it. */
1041 *input_line_pointer
= '(';
1042 ++input_line_pointer
;
1046 if (*input_line_pointer
!= ')')
1048 as_bad (_("Missing ')'"));
1049 *nextcharP
= *input_line_pointer
;
1053 ++input_line_pointer
;
1055 if (e
->X_op
== O_register
|| e
->X_op
== O_absent
)
1057 as_bad (_("Invalid expression."));
1058 e
->X_op
= O_constant
;
1059 e
->X_add_number
= 0;
1063 /* Wrap subexpression with a unary operator. */
1064 symbolS
*sym
= make_expr_symbol (e
);
1066 if (sym
!= e
->X_add_symbol
)
1068 /* HACK: mark this symbol as a temporary wrapper around a proper
1069 expression, so we can unwrap it later once we have communicated
1070 the relocation type. */
1071 symbol_get_value_expression (sym
)->X_md
= 1;
1074 memset (e
, 0, sizeof *e
);
1076 e
->X_add_symbol
= sym
;
1077 e
->X_add_number
= 0;
1080 *nextcharP
= *input_line_pointer
;
1085 /* Parses an expression which must be a register name. */
1088 parse_reg_expression (expressionS
* expression
)
1091 char terminating_char
;
1093 int regno_and_flags
;
1096 /* Zero everything to make sure we don't miss any flags. */
1097 memset (expression
, 0, sizeof *expression
);
1099 terminating_char
= get_symbol_name (®name
);
1101 pval
= hash_find (main_reg_hash
, regname
);
1103 as_bad (_("Expected register, got '%s'."), regname
);
1105 regno_and_flags
= (int)(size_t)pval
;
1106 regno
= EXTRACT_REGNO(regno_and_flags
);
1108 if ((regno_and_flags
& NONCANONICAL_REG_NAME_FLAG
)
1109 && require_canonical_reg_names
)
1110 as_warn (_("Found use of non-canonical register name %s; "
1112 regname
, tilegx_register_names
[regno
]);
1114 /* Restore the old character following the register name. */
1115 (void) restore_line_pointer (terminating_char
);
1117 /* Fill in the expression fields to indicate it's a register. */
1118 expression
->X_op
= O_register
;
1119 expression
->X_add_number
= regno
;
1123 /* Parses and type-checks comma-separated operands in input_line_pointer. */
1126 parse_operands (const char *opcode_name
,
1127 const unsigned char *operands
,
1129 expressionS
*operand_values
)
1133 memset (operand_values
, 0, num_operands
* sizeof operand_values
[0]);
1136 for (i
= 0; i
< num_operands
; i
++)
1138 tilegx_operand_type type
= tilegx_operands
[operands
[i
]].type
;
1142 if (type
== TILEGX_OP_TYPE_REGISTER
)
1144 parse_reg_expression (&operand_values
[i
]);
1146 else if (*input_line_pointer
== '}')
1148 operand_values
[i
].X_op
= O_absent
;
1150 else if (type
== TILEGX_OP_TYPE_SPR
)
1152 /* Modify the expression parser to add SPRs to the namespace. */
1154 expression (&operand_values
[i
]);
1159 expression (&operand_values
[i
]);
1164 if (i
+ 1 < num_operands
)
1166 int separator
= (unsigned char)*input_line_pointer
++;
1168 if (is_end_of_line
[separator
] || (separator
== '}'))
1170 as_bad (_("Too few operands to '%s'."), opcode_name
);
1173 else if (separator
!= ',')
1175 as_bad (_("Unexpected character '%c' after operand %d to %s."),
1176 (char)separator
, i
+ 1, opcode_name
);
1181 /* Arbitrarily use the first valid pipe to get the operand type,
1182 since they are all the same. */
1183 switch (tilegx_operands
[operands
[i
]].type
)
1185 case TILEGX_OP_TYPE_REGISTER
:
1186 /* Handled in parse_reg_expression already. */
1188 case TILEGX_OP_TYPE_SPR
:
1190 case TILEGX_OP_TYPE_IMMEDIATE
:
1192 case TILEGX_OP_TYPE_ADDRESS
:
1193 if ( operand_values
[i
].X_op
== O_register
1194 || operand_values
[i
].X_op
== O_illegal
1195 || operand_values
[i
].X_op
== O_absent
)
1196 as_bad (_("Expected immediate expression"));
1203 if (!is_end_of_line
[(unsigned char)*input_line_pointer
])
1205 switch (*input_line_pointer
)
1209 as_bad (_("Found '}' when not bundling."));
1210 ++input_line_pointer
;
1212 demand_empty_rest_of_line ();
1216 as_bad (_("Too many operands"));
1220 /* Use default error for unrecognized garbage. */
1221 demand_empty_rest_of_line ();
1228 /* This is the guts of the machine-dependent assembler. STR points to a
1229 machine dependent instruction. This function is supposed to emit the
1230 frags/bytes it assembles to. */
1233 md_assemble (char *str
)
1237 char *old_input_line_pointer
;
1238 const struct tilegx_opcode
*op
;
1241 /* Split off the opcode and look it up. */
1242 opname_len
= strcspn (str
, " {}");
1243 old_char
= str
[opname_len
];
1244 str
[opname_len
] = '\0';
1246 op
= hash_find(op_hash
, str
);
1247 str
[opname_len
] = old_char
;
1250 as_bad (_("Unknown opcode `%.*s'."), (int)opname_len
, str
);
1254 /* Prepare to parse the operands. */
1255 old_input_line_pointer
= input_line_pointer
;
1256 input_line_pointer
= str
+ opname_len
;
1259 if (current_bundle_index
== TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE
)
1261 as_bad (_("Too many instructions for bundle."));
1262 tilegx_flush_bundle ();
1265 /* Make sure we have room for the upcoming bundle before we
1266 create any fixups. Otherwise if we have to switch to a new
1267 frag the fixup dot_value fields will be wrong. */
1268 frag_grow (TILEGX_BUNDLE_SIZE_IN_BYTES
);
1270 /* Find a valid pipe for this opcode. */
1271 for (first_pipe
= 0; (op
->pipes
& (1 << first_pipe
)) == 0; first_pipe
++)
1274 /* Call the function that assembles this instruction. */
1275 current_bundle
[current_bundle_index
].opcode
= op
;
1276 parse_operands (op
->name
,
1277 &op
->operands
[first_pipe
][0],
1279 current_bundle
[current_bundle_index
].operand_values
);
1280 ++current_bundle_index
;
1282 /* Restore the saved value of input_line_pointer. */
1283 input_line_pointer
= old_input_line_pointer
;
1285 /* If we weren't inside curly braces, go ahead and emit
1286 this lone instruction as a bundle right now. */
1288 tilegx_flush_bundle ();
1293 s_require_canonical_reg_names (int require
)
1295 demand_empty_rest_of_line ();
1296 require_canonical_reg_names
= require
;
1300 s_allow_suspicious_bundles (int allow
)
1302 demand_empty_rest_of_line ();
1303 allow_suspicious_bundles
= allow
;
1306 const pseudo_typeS md_pseudo_table
[] =
1308 {"align", s_align_bytes
, 0}, /* Defaulting is invalid (0). */
1310 {"require_canonical_reg_names", s_require_canonical_reg_names
, 1 },
1311 {"no_require_canonical_reg_names", s_require_canonical_reg_names
, 0 },
1312 {"allow_suspicious_bundles", s_allow_suspicious_bundles
, 1 },
1313 {"no_allow_suspicious_bundles", s_allow_suspicious_bundles
, 0 },
1317 /* Equal to MAX_PRECISION in atof-ieee.c */
1318 #define MAX_LITTLENUMS 6
1321 md_number_to_chars (char * buf
, valueT val
, int n
)
1323 if (target_big_endian
)
1324 number_to_chars_bigendian (buf
, val
, n
);
1326 number_to_chars_littleendian (buf
, val
, n
);
1329 /* Turn the string pointed to by litP into a floating point constant
1330 of type TYPE, and emit the appropriate bytes. The number of
1331 LITTLENUMS emitted is stored in *SIZEP. An error message is
1332 returned, or NULL on OK. */
1335 md_atof (int type
, char *litP
, int *sizeP
)
1338 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
1339 LITTLENUM_TYPE
*wordP
;
1356 return _("Bad call to md_atof ()");
1358 t
= atof_ieee (input_line_pointer
, type
, words
);
1360 input_line_pointer
= t
;
1362 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
1363 /* This loops outputs the LITTLENUMs in REVERSE order; in accord with
1364 the bigendian 386. */
1365 for (wordP
= words
+ prec
- 1; prec
--;)
1367 md_number_to_chars (litP
, (valueT
) (*wordP
--), sizeof (LITTLENUM_TYPE
));
1368 litP
+= sizeof (LITTLENUM_TYPE
);
1374 /* We have no need to default values of symbols. */
1377 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
1384 tilegx_cons_fix_new (fragS
*frag
,
1390 bfd_reloc_code_real_type reloc
= BFD_RELOC_NONE
;
1391 int no_overflow
= 0;
1394 /* See if it's one of our special functions. */
1398 reloc
= BFD_RELOC_TILEGX_HW0
;
1402 reloc
= BFD_RELOC_TILEGX_HW1
;
1406 reloc
= BFD_RELOC_TILEGX_HW2
;
1410 reloc
= BFD_RELOC_TILEGX_HW3
;
1414 reloc
= BFD_RELOC_TILEGX_HW0_LAST
;
1417 reloc
= BFD_RELOC_TILEGX_HW1_LAST
;
1420 reloc
= BFD_RELOC_TILEGX_HW2_LAST
;
1428 if (reloc
!= BFD_RELOC_NONE
)
1432 as_bad (_("This operator only produces two byte values."));
1436 memset (&subexp
, 0, sizeof subexp
);
1437 subexp
.X_op
= O_symbol
;
1438 subexp
.X_add_symbol
= exp
->X_add_symbol
;
1446 reloc
= BFD_RELOC_8
;
1449 reloc
= BFD_RELOC_16
;
1452 reloc
= BFD_RELOC_32
;
1455 reloc
= BFD_RELOC_64
;
1458 as_bad (_("unsupported BFD relocation size %d"), nbytes
);
1459 reloc
= BFD_RELOC_64
;
1464 fixP
= fix_new_exp (frag
, where
, nbytes
, exp
, 0, reloc
);
1465 fixP
->tc_fix_data
= NULL
;
1466 fixP
->fx_no_overflow
|= no_overflow
;
1471 md_apply_fix (fixS
*fixP
, valueT
* valP
, segT seg ATTRIBUTE_UNUSED
)
1473 const struct tilegx_operand
*operand
;
1474 valueT value
= *valP
;
1478 /* Leave these for the linker. */
1479 if (fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
1480 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
1483 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
1485 /* We can't actually support subtracting a symbol. */
1486 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
1489 /* Correct relocation types for pc-relativeness. */
1490 switch (fixP
->fx_r_type
)
1492 #define FIX_PCREL(rtype) \
1494 if (fixP->fx_pcrel) \
1495 fixP->fx_r_type = rtype##_PCREL; \
1498 case rtype##_PCREL: \
1499 if (!fixP->fx_pcrel) \
1500 fixP->fx_r_type = rtype; \
1503 #define FIX_PLT_PCREL(rtype) \
1504 case rtype##_PLT_PCREL: \
1505 if (!fixP->fx_pcrel) \
1506 fixP->fx_r_type = rtype; \
1510 FIX_PCREL (BFD_RELOC_8
);
1511 FIX_PCREL (BFD_RELOC_16
);
1512 FIX_PCREL (BFD_RELOC_32
);
1513 FIX_PCREL (BFD_RELOC_64
);
1514 FIX_PCREL (BFD_RELOC_TILEGX_IMM16_X0_HW0
);
1515 FIX_PCREL (BFD_RELOC_TILEGX_IMM16_X1_HW0
);
1516 FIX_PCREL (BFD_RELOC_TILEGX_IMM16_X0_HW1
);
1517 FIX_PCREL (BFD_RELOC_TILEGX_IMM16_X1_HW1
);
1518 FIX_PCREL (BFD_RELOC_TILEGX_IMM16_X0_HW2
);
1519 FIX_PCREL (BFD_RELOC_TILEGX_IMM16_X1_HW2
);
1520 FIX_PCREL (BFD_RELOC_TILEGX_IMM16_X0_HW3
);
1521 FIX_PCREL (BFD_RELOC_TILEGX_IMM16_X1_HW3
);
1522 FIX_PCREL (BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST
);
1523 FIX_PCREL (BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST
);
1524 FIX_PCREL (BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST
);
1525 FIX_PCREL (BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST
);
1526 FIX_PCREL (BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST
);
1527 FIX_PCREL (BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST
);
1528 FIX_PLT_PCREL (BFD_RELOC_TILEGX_IMM16_X0_HW0
);
1529 FIX_PLT_PCREL (BFD_RELOC_TILEGX_IMM16_X1_HW0
);
1530 FIX_PLT_PCREL (BFD_RELOC_TILEGX_IMM16_X0_HW1
);
1531 FIX_PLT_PCREL (BFD_RELOC_TILEGX_IMM16_X1_HW1
);
1532 FIX_PLT_PCREL (BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST
);
1533 FIX_PLT_PCREL (BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST
);
1534 FIX_PLT_PCREL (BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST
);
1535 FIX_PLT_PCREL (BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST
);
1544 if (fixP
->fx_addsy
!= NULL
)
1547 switch (fixP
->fx_r_type
)
1549 case BFD_RELOC_TILEGX_IMM8_X0_TLS_ADD
:
1550 case BFD_RELOC_TILEGX_IMM8_X1_TLS_ADD
:
1551 case BFD_RELOC_TILEGX_IMM8_Y0_TLS_ADD
:
1552 case BFD_RELOC_TILEGX_IMM8_Y1_TLS_ADD
:
1553 case BFD_RELOC_TILEGX_IMM8_X0_TLS_GD_ADD
:
1554 case BFD_RELOC_TILEGX_IMM8_X1_TLS_GD_ADD
:
1555 case BFD_RELOC_TILEGX_IMM8_Y0_TLS_GD_ADD
:
1556 case BFD_RELOC_TILEGX_IMM8_Y1_TLS_GD_ADD
:
1557 case BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_GD
:
1558 case BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_GD
:
1559 case BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_GD
:
1560 case BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_GD
:
1561 case BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_GD
:
1562 case BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_GD
:
1563 case BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_IE
:
1564 case BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_IE
:
1565 case BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_IE
:
1566 case BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_IE
:
1567 case BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_IE
:
1568 case BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_IE
:
1569 case BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_LE
:
1570 case BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_LE
:
1571 case BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_LE
:
1572 case BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_LE
:
1573 case BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_LE
:
1574 case BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_LE
:
1575 case BFD_RELOC_TILEGX_TLS_GD_CALL
:
1576 case BFD_RELOC_TILEGX_TLS_IE_LOAD
:
1577 case BFD_RELOC_TILEGX_TLS_DTPMOD64
:
1578 case BFD_RELOC_TILEGX_TLS_DTPOFF64
:
1579 case BFD_RELOC_TILEGX_TLS_TPOFF64
:
1580 case BFD_RELOC_TILEGX_TLS_DTPMOD32
:
1581 case BFD_RELOC_TILEGX_TLS_DTPOFF32
:
1582 case BFD_RELOC_TILEGX_TLS_TPOFF32
:
1583 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
1594 /* Apply hw0, etc. */
1595 special
= O_illegal
;
1596 switch (fixP
->fx_r_type
)
1598 case BFD_RELOC_TILEGX_HW0
:
1599 case BFD_RELOC_TILEGX_IMM16_X0_HW0
:
1600 case BFD_RELOC_TILEGX_IMM16_X1_HW0
:
1601 case BFD_RELOC_TILEGX_IMM16_X0_HW0_PCREL
:
1602 case BFD_RELOC_TILEGX_IMM16_X1_HW0_PCREL
:
1603 case BFD_RELOC_TILEGX_IMM16_X0_HW0_PLT_PCREL
:
1604 case BFD_RELOC_TILEGX_IMM16_X1_HW0_PLT_PCREL
:
1608 case BFD_RELOC_TILEGX_HW0_LAST
:
1609 case BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST
:
1610 case BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST
:
1611 case BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_PCREL
:
1612 case BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_PCREL
:
1613 case BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL
:
1614 case BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL
:
1615 special
= O_hw0_last
;
1618 case BFD_RELOC_TILEGX_HW1
:
1619 case BFD_RELOC_TILEGX_IMM16_X0_HW1
:
1620 case BFD_RELOC_TILEGX_IMM16_X1_HW1
:
1621 case BFD_RELOC_TILEGX_IMM16_X0_HW1_PCREL
:
1622 case BFD_RELOC_TILEGX_IMM16_X1_HW1_PCREL
:
1623 case BFD_RELOC_TILEGX_IMM16_X0_HW1_PLT_PCREL
:
1624 case BFD_RELOC_TILEGX_IMM16_X1_HW1_PLT_PCREL
:
1628 case BFD_RELOC_TILEGX_HW1_LAST
:
1629 case BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST
:
1630 case BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST
:
1631 case BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_PCREL
:
1632 case BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_PCREL
:
1633 case BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL
:
1634 case BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL
:
1635 special
= O_hw1_last
;
1638 case BFD_RELOC_TILEGX_HW2
:
1639 case BFD_RELOC_TILEGX_IMM16_X0_HW2
:
1640 case BFD_RELOC_TILEGX_IMM16_X1_HW2
:
1641 case BFD_RELOC_TILEGX_IMM16_X0_HW2_PCREL
:
1642 case BFD_RELOC_TILEGX_IMM16_X1_HW2_PCREL
:
1643 case BFD_RELOC_TILEGX_IMM16_X0_HW2_PLT_PCREL
:
1644 case BFD_RELOC_TILEGX_IMM16_X1_HW2_PLT_PCREL
:
1648 case BFD_RELOC_TILEGX_HW2_LAST
:
1649 case BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST
:
1650 case BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST
:
1651 case BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST_PCREL
:
1652 case BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST_PCREL
:
1653 case BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL
:
1654 case BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL
:
1655 special
= O_hw2_last
;
1658 case BFD_RELOC_TILEGX_HW3
:
1659 case BFD_RELOC_TILEGX_IMM16_X0_HW3
:
1660 case BFD_RELOC_TILEGX_IMM16_X1_HW3
:
1661 case BFD_RELOC_TILEGX_IMM16_X0_HW3_PCREL
:
1662 case BFD_RELOC_TILEGX_IMM16_X1_HW3_PCREL
:
1663 case BFD_RELOC_TILEGX_IMM16_X0_HW3_PLT_PCREL
:
1664 case BFD_RELOC_TILEGX_IMM16_X1_HW3_PLT_PCREL
:
1673 if (special
!= O_illegal
)
1675 *valP
= value
= apply_special_operator (special
, value
,
1676 fixP
->fx_file
, fixP
->fx_line
);
1679 p
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
1681 operand
= fixP
->tc_fix_data
;
1682 if (operand
!= NULL
)
1684 /* It's an instruction operand. */
1685 tilegx_bundle_bits bits
=
1686 insert_operand (0, operand
, value
, fixP
->fx_file
, fixP
->fx_line
);
1688 /* Note that we might either be writing out bits for a bundle
1689 or a static network instruction, which are different sizes, so it's
1690 important to stop touching memory once we run out of bits.
1691 ORing in values is OK since we know the existing bits for
1692 this operand are zero. */
1693 for (; bits
!= 0; bits
>>= 8)
1698 /* Some other kind of relocation. */
1699 switch (fixP
->fx_r_type
)
1702 case BFD_RELOC_8_PCREL
:
1703 md_number_to_chars (p
, value
, 1);
1707 case BFD_RELOC_16_PCREL
:
1708 md_number_to_chars (p
, value
, 2);
1712 case BFD_RELOC_32_PCREL
:
1713 md_number_to_chars (p
, value
, 4);
1717 case BFD_RELOC_64_PCREL
:
1718 md_number_to_chars (p
, value
, 8);
1722 /* Leave it for the linker. */
1731 /* Generate the BFD reloc to be stuck in the object file from the
1732 fixup used internally in the assembler. */
1735 tc_gen_reloc (asection
*sec ATTRIBUTE_UNUSED
, fixS
*fixp
)
1739 reloc
= XNEW (arelent
);
1740 reloc
->sym_ptr_ptr
= XNEW (asymbol
*);
1741 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
1742 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
1744 /* Make sure none of our internal relocations make it this far.
1745 They'd better have been fully resolved by this point. */
1746 gas_assert ((int) fixp
->fx_r_type
> 0);
1748 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
1749 if (reloc
->howto
== NULL
)
1751 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1752 _("cannot represent `%s' relocation in object file"),
1753 bfd_get_reloc_code_name (fixp
->fx_r_type
));
1757 if (!fixp
->fx_pcrel
!= !reloc
->howto
->pc_relative
)
1759 as_fatal (_("internal error? cannot generate `%s' relocation (%d, %d)"),
1760 bfd_get_reloc_code_name (fixp
->fx_r_type
),
1761 fixp
->fx_pcrel
, reloc
->howto
->pc_relative
);
1763 gas_assert (!fixp
->fx_pcrel
== !reloc
->howto
->pc_relative
);
1765 reloc
->addend
= fixp
->fx_offset
;
1771 /* The location from which a PC relative jump should be calculated,
1772 given a PC relative reloc. */
1775 md_pcrel_from (fixS
*fixP
)
1777 return fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
1781 /* Return 1 if it's OK to adjust a reloc by replacing the symbol with
1782 a section symbol plus some offset. */
1784 tilegx_fix_adjustable (fixS
*fix
)
1786 /* Prevent all adjustments to global symbols */
1787 if (S_IS_EXTERNAL (fix
->fx_addsy
) || S_IS_WEAK (fix
->fx_addsy
))
1795 tilegx_unrecognized_line (int ch
)
1802 as_bad (_("Found '{' when already bundling."));
1807 current_bundle_index
= 0;
1814 as_bad (_("Found '}' when not bundling."));
1818 tilegx_flush_bundle ();
1821 /* Allow '{' to follow on the same line. We also allow ";;", but that
1822 happens automatically because ';' is an end of line marker. */
1824 if (input_line_pointer
[0] == '{')
1826 input_line_pointer
++;
1827 return tilegx_unrecognized_line ('{');
1830 demand_empty_rest_of_line ();
1837 /* Not a valid line. */
1842 /* This is called from HANDLE_ALIGN in write.c. Fill in the contents
1843 of an rs_align_code fragment. */
1846 tilegx_handle_align (fragS
*fragp
)
1848 addressT bytes
, fix
;
1851 if (fragp
->fr_type
!= rs_align_code
)
1854 bytes
= fragp
->fr_next
->fr_address
- fragp
->fr_address
- fragp
->fr_fix
;
1855 p
= fragp
->fr_literal
+ fragp
->fr_fix
;
1858 /* Determine the bits for NOP. */
1859 const struct tilegx_opcode
*nop_opcode
=
1860 &tilegx_opcodes
[TILEGX_OPC_NOP
];
1861 tilegx_bundle_bits nop
=
1862 ( nop_opcode
->fixed_bit_values
[TILEGX_PIPELINE_X0
]
1863 | nop_opcode
->fixed_bit_values
[TILEGX_PIPELINE_X1
]);
1865 if ((bytes
& (TILEGX_BUNDLE_SIZE_IN_BYTES
- 1)) != 0)
1867 fix
= bytes
& (TILEGX_BUNDLE_SIZE_IN_BYTES
- 1);
1873 number_to_chars_littleendian (p
, nop
, 8);
1874 fragp
->fr_fix
+= fix
;
1875 fragp
->fr_var
= TILEGX_BUNDLE_SIZE_IN_BYTES
;
1878 /* Standard calling conventions leave the CFA at SP on entry. */
1880 tilegx_cfi_frame_initial_instructions (void)
1882 cfi_add_CFA_def_cfa_register (54);
1886 tc_tilegx_regname_to_dw2regnum (char *regname
)
1889 for (i
= 0; i
< TILEGX_NUM_REGISTERS
; i
++)
1891 if (!strcmp (regname
, tilegx_register_names
[i
]))