1 /* tc-tilepro.c -- Assemble for a TILEPro chip.
2 Copyright (C) 2011-2023 Free Software Foundation, Inc.
3
4 This file is part of GAS, the GNU Assembler.
5
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.
10
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.
15
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. */
20
21 #include "as.h"
22 #include "subsegs.h"
23
24 #include "elf/tilepro.h"
25 #include "opcode/tilepro.h"
26
27 #include "dwarf2dbg.h"
28 #include "dw2gencfi.h"
29
30 #include "safe-ctype.h"
31
32
33 /* Special registers. */
34 #define TREG_IDN0 57
35 #define TREG_IDN1 58
36 #define TREG_UDN0 59
37 #define TREG_UDN1 60
38 #define TREG_UDN2 61
39 #define TREG_UDN3 62
40 #define TREG_ZERO 63
41
42
43 /* Generic assembler global variables which must be defined by all
44 targets. */
45
46 /* Characters which always start a comment. */
47 const char comment_chars[] = "#";
48
49 /* Characters which start a comment at the beginning of a line. */
50 const char line_comment_chars[] = "#";
51
52 /* Characters which may be used to separate multiple commands on a
53 single line. */
54 const char line_separator_chars[] = ";";
55
56 /* Characters which are used to indicate an exponent in a floating
57 point number. */
58 const char EXP_CHARS[] = "eE";
59
60 /* Characters which mean that a number is a floating point constant,
61 as in 0d1.0. */
62 const char FLT_CHARS[] = "rRsSfFdDxXpP";
63
64 const char *md_shortopts = "VQ:";
65
66 struct option md_longopts[] =
67 {
68 {NULL, no_argument, NULL, 0}
69 };
70
71 size_t md_longopts_size = sizeof (md_longopts);
72
73 int
74 md_parse_option (int c, const char *arg ATTRIBUTE_UNUSED)
75 {
76 switch (c)
77 {
78 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
79 should be emitted or not. FIXME: Not implemented. */
80 case 'Q':
81 break;
82
83 /* -V: SVR4 argument to print version ID. */
84 case 'V':
85 print_version_id ();
86 break;
87
88 default:
89 return 0;
90 }
91
92 return 1;
93 }
94
95 void
96 md_show_usage (FILE *stream)
97 {
98 fprintf (stream, _("\
99 -Q ignored\n\
100 -V print assembler version number\n"));
101 }
102
103 /* Extra expression types. */
104
105 #define O_lo16 O_md1
106 #define O_hi16 O_md2
107 #define O_ha16 O_md3
108 #define O_got O_md4
109 #define O_got_lo16 O_md5
110 #define O_got_hi16 O_md6
111 #define O_got_ha16 O_md7
112 #define O_plt O_md8
113 #define O_tls_gd O_md9
114 #define O_tls_gd_lo16 O_md10
115 #define O_tls_gd_hi16 O_md11
116 #define O_tls_gd_ha16 O_md12
117 #define O_tls_ie O_md13
118 #define O_tls_ie_lo16 O_md14
119 #define O_tls_ie_hi16 O_md15
120 #define O_tls_ie_ha16 O_md16
121 #define O_tls_le O_md17
122 #define O_tls_le_lo16 O_md18
123 #define O_tls_le_hi16 O_md19
124 #define O_tls_le_ha16 O_md20
125 #define O_tls_gd_call O_md21
126 #define O_tls_gd_add O_md22
127 #define O_tls_ie_load O_md23
128
129 static htab_t special_operator_hash;
130
131 /* Hash tables for instruction mnemonic lookup. */
132 static htab_t op_hash;
133
134 /* Hash table for spr lookup. */
135 static htab_t spr_hash;
136
137 /* True temporarily while parsing an SPR expression. This changes the
138 * namespace to include SPR names. */
139 static int parsing_spr;
140
141 /* Are we currently inside `{ ... }'? */
142 static int inside_bundle;
143
144 struct tilepro_instruction
145 {
146 const struct tilepro_opcode *opcode;
147 tilepro_pipeline pipe;
148 expressionS operand_values[TILEPRO_MAX_OPERANDS];
149 };
150
151 /* This keeps track of the current bundle being built up. */
152 static struct tilepro_instruction
153 current_bundle[TILEPRO_MAX_INSTRUCTIONS_PER_BUNDLE];
154
155 /* Index in current_bundle for the next instruction to parse. */
156 static int current_bundle_index;
157
158 /* Allow 'r63' in addition to 'zero', etc. Normally we disallow this as
159 'zero' is not a real register, so using it accidentally would be a
160 nasty bug. For other registers, such as 'sp', code using multiple names
161 for the same physical register is excessively confusing.
162
163 The '.require_canonical_reg_names' pseudo-op turns this error on,
164 and the '.no_require_canonical_reg_names' pseudo-op turns this off.
165 By default the error is on. */
166 static int require_canonical_reg_names;
167
168 /* Allow bundles that do undefined or suspicious things like write
169 two different values to the same register at the same time.
170
171 The '.no_allow_suspicious_bundles' pseudo-op turns this error on,
172 and the '.allow_suspicious_bundles' pseudo-op turns this off. */
173 static int allow_suspicious_bundles;
174
175
176 /* A hash table of main processor registers, mapping each register name
177 to its index.
178
179 Furthermore, if the register number is greater than the number
180 of registers for that processor, the user used an illegal alias
181 for that register (e.g. r63 instead of zero), so we should generate
182 a warning. The attempted register number can be found by clearing
183 NONCANONICAL_REG_NAME_FLAG. */
184 static htab_t main_reg_hash;
185
186
187 /* We cannot unambiguously store a 0 in a hash table and look it up,
188 so we OR in this flag to every canonical register. */
189 #define CANONICAL_REG_NAME_FLAG 0x1000
190
191 /* By default we disallow register aliases like r63, but we record
192 them in the hash table in case the .no_require_canonical_reg_names
193 directive is used. Noncanonical names have this value added to them. */
194 #define NONCANONICAL_REG_NAME_FLAG 0x2000
195
196 /* Discards flags for register hash table entries and returns the
197 reg number. */
198 #define EXTRACT_REGNO(p) ((p) & 63)
199
200 /* This function is called once, at assembler startup time. It should
201 set up all the tables, etc., that the MD part of the assembler will
202 need. */
203 void
204 md_begin (void)
205 {
206 const struct tilepro_opcode *op;
207 int i;
208
209 /* Guarantee text section is aligned. */
210 bfd_set_section_alignment (text_section,
211 TILEPRO_LOG2_BUNDLE_ALIGNMENT_IN_BYTES);
212
213 require_canonical_reg_names = 1;
214 allow_suspicious_bundles = 0;
215 current_bundle_index = 0;
216 inside_bundle = 0;
217
218 /* Initialize special operator hash table. */
219 special_operator_hash = str_htab_create ();
220 #define INSERT_SPECIAL_OP(name) \
221 str_hash_insert (special_operator_hash, #name, (void *) O_##name, 0)
222
223 INSERT_SPECIAL_OP(lo16);
224 INSERT_SPECIAL_OP(hi16);
225 INSERT_SPECIAL_OP(ha16);
226 INSERT_SPECIAL_OP(got);
227 INSERT_SPECIAL_OP(got_lo16);
228 INSERT_SPECIAL_OP(got_hi16);
229 INSERT_SPECIAL_OP(got_ha16);
230 INSERT_SPECIAL_OP(plt);
231 INSERT_SPECIAL_OP(tls_gd);
232 INSERT_SPECIAL_OP(tls_gd_lo16);
233 INSERT_SPECIAL_OP(tls_gd_hi16);
234 INSERT_SPECIAL_OP(tls_gd_ha16);
235 INSERT_SPECIAL_OP(tls_ie);
236 INSERT_SPECIAL_OP(tls_ie_lo16);
237 INSERT_SPECIAL_OP(tls_ie_hi16);
238 INSERT_SPECIAL_OP(tls_ie_ha16);
239 INSERT_SPECIAL_OP(tls_le);
240 INSERT_SPECIAL_OP(tls_le_lo16);
241 INSERT_SPECIAL_OP(tls_le_hi16);
242 INSERT_SPECIAL_OP(tls_le_ha16);
243 INSERT_SPECIAL_OP(tls_gd_call);
244 INSERT_SPECIAL_OP(tls_gd_add);
245 INSERT_SPECIAL_OP(tls_ie_load);
246 #undef INSERT_SPECIAL_OP
247
248 /* Initialize op_hash hash table. */
249 op_hash = str_htab_create ();
250 for (op = &tilepro_opcodes[0]; op->name != NULL; op++)
251 if (str_hash_insert (op_hash, op->name, op, 0) != NULL)
252 as_fatal (_("duplicate %s"), op->name);
253
254 /* Initialize the spr hash table. */
255 parsing_spr = 0;
256 spr_hash = str_htab_create ();
257 for (i = 0; i < tilepro_num_sprs; i++)
258 str_hash_insert (spr_hash, tilepro_sprs[i].name, &tilepro_sprs[i], 0);
259
260 /* Set up the main_reg_hash table. We use this instead of
261 * creating a symbol in the register section to avoid ambiguities
262 * with labels that have the same names as registers. */
263 main_reg_hash = str_htab_create ();
264 for (i = 0; i < TILEPRO_NUM_REGISTERS; i++)
265 {
266 char buf[64];
267
268 str_hash_insert (main_reg_hash, tilepro_register_names[i],
269 (void *) (long) (i | CANONICAL_REG_NAME_FLAG), 0);
270
271 /* See if we should insert a noncanonical alias, like r63. */
272 sprintf (buf, "r%d", i);
273 if (strcmp (buf, tilepro_register_names[i]) != 0)
274 str_hash_insert (main_reg_hash, xstrdup (buf),
275 (void *) (long) (i | NONCANONICAL_REG_NAME_FLAG), 0);
276 }
277
278 /* Insert obsolete backwards-compatibility register names. */
279 str_hash_insert (main_reg_hash, "io0",
280 (void *) (long) (TREG_IDN0 | CANONICAL_REG_NAME_FLAG), 0);
281 str_hash_insert (main_reg_hash, "io1",
282 (void *) (long) (TREG_IDN1 | CANONICAL_REG_NAME_FLAG), 0);
283 str_hash_insert (main_reg_hash, "us0",
284 (void *) (long) (TREG_UDN0 | CANONICAL_REG_NAME_FLAG), 0);
285 str_hash_insert (main_reg_hash, "us1",
286 (void *) (long) (TREG_UDN1 | CANONICAL_REG_NAME_FLAG), 0);
287 str_hash_insert (main_reg_hash, "us2",
288 (void *) (long) (TREG_UDN2 | CANONICAL_REG_NAME_FLAG), 0);
289 str_hash_insert (main_reg_hash, "us3",
290 (void *) (long) (TREG_UDN3 | CANONICAL_REG_NAME_FLAG), 0);
291
292 }
293
294
295 #define BUNDLE_TEMPLATE_MASK(p0, p1, p2) \
296 ((p0) | ((p1) << 8) | ((p2) << 16))
297 #define BUNDLE_TEMPLATE(p0, p1, p2) \
298 { { (p0), (p1), (p2) }, \
299 BUNDLE_TEMPLATE_MASK(1 << (p0), 1 << (p1), (1 << (p2))) \
300 }
301
302 #define NO_PIPELINE TILEPRO_NUM_PIPELINE_ENCODINGS
303
304 struct bundle_template
305 {
306 tilepro_pipeline pipe[TILEPRO_MAX_INSTRUCTIONS_PER_BUNDLE];
307 unsigned int pipe_mask;
308 };
309
310 static const struct bundle_template bundle_templates[] =
311 {
312 /* In Y format we must always have something in Y2, since it has
313 * no fnop, so this conveys that Y2 must always be used. */
314 BUNDLE_TEMPLATE(TILEPRO_PIPELINE_Y0, TILEPRO_PIPELINE_Y2, NO_PIPELINE),
315 BUNDLE_TEMPLATE(TILEPRO_PIPELINE_Y1, TILEPRO_PIPELINE_Y2, NO_PIPELINE),
316 BUNDLE_TEMPLATE(TILEPRO_PIPELINE_Y2, TILEPRO_PIPELINE_Y0, NO_PIPELINE),
317 BUNDLE_TEMPLATE(TILEPRO_PIPELINE_Y2, TILEPRO_PIPELINE_Y1, NO_PIPELINE),
318
319 /* Y format has three instructions. */
320 BUNDLE_TEMPLATE(TILEPRO_PIPELINE_Y0, TILEPRO_PIPELINE_Y1, TILEPRO_PIPELINE_Y2),
321 BUNDLE_TEMPLATE(TILEPRO_PIPELINE_Y0, TILEPRO_PIPELINE_Y2, TILEPRO_PIPELINE_Y1),
322 BUNDLE_TEMPLATE(TILEPRO_PIPELINE_Y1, TILEPRO_PIPELINE_Y0, TILEPRO_PIPELINE_Y2),
323 BUNDLE_TEMPLATE(TILEPRO_PIPELINE_Y1, TILEPRO_PIPELINE_Y2, TILEPRO_PIPELINE_Y0),
324 BUNDLE_TEMPLATE(TILEPRO_PIPELINE_Y2, TILEPRO_PIPELINE_Y0, TILEPRO_PIPELINE_Y1),
325 BUNDLE_TEMPLATE(TILEPRO_PIPELINE_Y2, TILEPRO_PIPELINE_Y1, TILEPRO_PIPELINE_Y0),
326
327 /* X format has only two instructions. */
328 BUNDLE_TEMPLATE(TILEPRO_PIPELINE_X0, TILEPRO_PIPELINE_X1, NO_PIPELINE),
329 BUNDLE_TEMPLATE(TILEPRO_PIPELINE_X1, TILEPRO_PIPELINE_X0, NO_PIPELINE)
330 };
331
332
333 static void
334 prepend_nop_to_bundle (tilepro_mnemonic mnemonic)
335 {
336 memmove (¤t_bundle[1], ¤t_bundle[0],
337 current_bundle_index * sizeof current_bundle[0]);
338 current_bundle[0].opcode = &tilepro_opcodes[mnemonic];
339 ++current_bundle_index;
340 }
341
342
343 static tilepro_bundle_bits
344 insert_operand (tilepro_bundle_bits bits,
345 const struct tilepro_operand *operand,
346 int operand_value,
347 const char *file,
348 unsigned lineno)
349 {
350 /* Range-check the immediate. */
351 int num_bits = operand->num_bits;
352
353 operand_value >>= operand->rightshift;
354
355 if (bfd_check_overflow (operand->is_signed
356 ? complain_overflow_signed
357 : complain_overflow_unsigned,
358 num_bits,
359 0,
360 bfd_arch_bits_per_address (stdoutput),
361 operand_value)
362 != bfd_reloc_ok)
363 {
364 offsetT min, max;
365 if (operand->is_signed)
366 {
367 min = -(1 << (num_bits - 1));
368 max = (1 << (num_bits - 1)) - 1;
369 }
370 else
371 {
372 min = 0;
373 max = (1 << num_bits) - 1;
374 }
375 as_bad_value_out_of_range (_("operand"), operand_value, min, max,
376 file, lineno);
377 }
378
379 /* Write out the bits for the immediate. */
380 return bits | operand->insert (operand_value);
381 }
382
383
384 static int
385 apply_special_operator (operatorT op, int num)
386 {
387 switch (op)
388 {
389 case O_lo16:
390 return (signed short)num;
391
392 case O_hi16:
393 return (signed short)(num >> 16);
394
395 case O_ha16:
396 return (signed short)((num + 0x8000) >> 16);
397
398 default:
399 abort ();
400 }
401 }
402
403
404 static tilepro_bundle_bits
405 emit_tilepro_instruction (tilepro_bundle_bits bits,
406 int num_operands,
407 const unsigned char *operands,
408 expressionS *operand_values,
409 char *bundle_start)
410 {
411 int i;
412
413 for (i = 0; i < num_operands; i++)
414 {
415 const struct tilepro_operand *operand =
416 &tilepro_operands[operands[i]];
417 expressionS *operand_exp = &operand_values[i];
418 int is_pc_relative = operand->is_pc_relative;
419
420 if (operand_exp->X_op == O_register
421 || (operand_exp->X_op == O_constant && !is_pc_relative))
422 {
423 /* We know what the bits are right now, so insert them. */
424 bits = insert_operand (bits, operand, operand_exp->X_add_number,
425 NULL, 0);
426 }
427 else
428 {
429 bfd_reloc_code_real_type reloc = operand->default_reloc;
430 expressionS subexp;
431 int die = 0, use_subexp = 0, require_symbol = 0;
432 fixS *fixP;
433
434 /* Take an expression like hi16(x) and turn it into x with
435 a different reloc type. */
436 switch (operand_exp->X_op)
437 {
438 #define HANDLE_OP16(suffix) \
439 switch (reloc) \
440 { \
441 case BFD_RELOC_TILEPRO_IMM16_X0: \
442 reloc = BFD_RELOC_TILEPRO_IMM16_X0_##suffix; \
443 break; \
444 case BFD_RELOC_TILEPRO_IMM16_X1: \
445 reloc = BFD_RELOC_TILEPRO_IMM16_X1_##suffix; \
446 break; \
447 default: \
448 die = 1; \
449 break; \
450 } \
451 use_subexp = 1
452
453 case O_lo16:
454 HANDLE_OP16 (LO);
455 break;
456
457 case O_hi16:
458 HANDLE_OP16 (HI);
459 break;
460
461 case O_ha16:
462 HANDLE_OP16 (HA);
463 break;
464
465 case O_got:
466 HANDLE_OP16 (GOT);
467 require_symbol = 1;
468 break;
469
470 case O_got_lo16:
471 HANDLE_OP16 (GOT_LO);
472 require_symbol = 1;
473 break;
474
475 case O_got_hi16:
476 HANDLE_OP16 (GOT_HI);
477 require_symbol = 1;
478 break;
479
480 case O_got_ha16:
481 HANDLE_OP16 (GOT_HA);
482 require_symbol = 1;
483 break;
484
485 case O_tls_gd:
486 HANDLE_OP16 (TLS_GD);
487 require_symbol = 1;
488 break;
489
490 case O_tls_gd_lo16:
491 HANDLE_OP16 (TLS_GD_LO);
492 require_symbol = 1;
493 break;
494
495 case O_tls_gd_hi16:
496 HANDLE_OP16 (TLS_GD_HI);
497 require_symbol = 1;
498 break;
499
500 case O_tls_gd_ha16:
501 HANDLE_OP16 (TLS_GD_HA);
502 require_symbol = 1;
503 break;
504
505 case O_tls_ie:
506 HANDLE_OP16 (TLS_IE);
507 require_symbol = 1;
508 break;
509
510 case O_tls_ie_lo16:
511 HANDLE_OP16 (TLS_IE_LO);
512 require_symbol = 1;
513 break;
514
515 case O_tls_ie_hi16:
516 HANDLE_OP16 (TLS_IE_HI);
517 require_symbol = 1;
518 break;
519
520 case O_tls_ie_ha16:
521 HANDLE_OP16 (TLS_IE_HA);
522 require_symbol = 1;
523 break;
524
525 case O_tls_le:
526 HANDLE_OP16 (TLS_LE);
527 require_symbol = 1;
528 break;
529
530 case O_tls_le_lo16:
531 HANDLE_OP16 (TLS_LE_LO);
532 require_symbol = 1;
533 break;
534
535 case O_tls_le_hi16:
536 HANDLE_OP16 (TLS_LE_HI);
537 require_symbol = 1;
538 break;
539
540 case O_tls_le_ha16:
541 HANDLE_OP16 (TLS_LE_HA);
542 require_symbol = 1;
543 break;
544
545 #undef HANDLE_OP16
546
547 case O_plt:
548 switch (reloc)
549 {
550 case BFD_RELOC_TILEPRO_JOFFLONG_X1:
551 reloc = BFD_RELOC_TILEPRO_JOFFLONG_X1_PLT;
552 break;
553 default:
554 die = 1;
555 break;
556 }
557 use_subexp = 1;
558 require_symbol = 1;
559 break;
560
561 case O_tls_gd_call:
562 switch (reloc)
563 {
564 case BFD_RELOC_TILEPRO_JOFFLONG_X1:
565 reloc = BFD_RELOC_TILEPRO_TLS_GD_CALL;
566 break;
567 default:
568 die = 1;
569 break;
570 }
571 use_subexp = 1;
572 require_symbol = 1;
573 break;
574
575 case O_tls_gd_add:
576 switch (reloc)
577 {
578 case BFD_RELOC_TILEPRO_IMM8_X0:
579 reloc = BFD_RELOC_TILEPRO_IMM8_X0_TLS_GD_ADD;
580 break;
581 case BFD_RELOC_TILEPRO_IMM8_X1:
582 reloc = BFD_RELOC_TILEPRO_IMM8_X1_TLS_GD_ADD;
583 break;
584 case BFD_RELOC_TILEPRO_IMM8_Y0:
585 reloc = BFD_RELOC_TILEPRO_IMM8_Y0_TLS_GD_ADD;
586 break;
587 case BFD_RELOC_TILEPRO_IMM8_Y1:
588 reloc = BFD_RELOC_TILEPRO_IMM8_Y1_TLS_GD_ADD;
589 break;
590 default:
591 die = 1;
592 break;
593 }
594 use_subexp = 1;
595 require_symbol = 1;
596 break;
597
598 case O_tls_ie_load:
599 switch (reloc)
600 {
601 case BFD_RELOC_TILEPRO_IMM8_X1:
602 reloc = BFD_RELOC_TILEPRO_TLS_IE_LOAD;
603 break;
604 default:
605 die = 1;
606 break;
607 }
608 use_subexp = 1;
609 require_symbol = 1;
610 break;
611
612 default:
613 /* Do nothing. */
614 break;
615 }
616
617 if (die)
618 {
619 as_bad (_("Invalid operator for operand."));
620 }
621 else if (use_subexp)
622 {
623 expressionS *sval = NULL;
624 /* Now that we've changed the reloc, change ha16(x) into x,
625 etc. */
626
627 if (symbol_symbolS (operand_exp->X_add_symbol))
628 sval = symbol_get_value_expression (operand_exp->X_add_symbol);
629 if (sval && sval->X_md)
630 {
631 /* HACK: We used X_md to mark this symbol as a fake wrapper
632 around a real expression. To unwrap it, we just grab its
633 value here. */
634 operand_exp = sval;
635
636 if (require_symbol)
637 {
638 /* Look at the expression, and reject it if it's not a
639 plain symbol. */
640 if (operand_exp->X_op != O_symbol
641 || operand_exp->X_add_number != 0)
642 as_bad (_("Operator may only be applied to symbols."));
643 }
644 }
645 else
646 {
647 /* The value of this expression is an actual symbol, so
648 turn that into an expression. */
649 memset (&subexp, 0, sizeof subexp);
650 subexp.X_op = O_symbol;
651 subexp.X_add_symbol = operand_exp->X_add_symbol;
652 operand_exp = &subexp;
653 }
654 }
655
656 /* Create a fixup to handle this later. */
657 fixP = fix_new_exp (frag_now,
658 bundle_start - frag_now->fr_literal,
659 (operand->num_bits + 7) >> 3,
660 operand_exp,
661 is_pc_relative,
662 reloc);
663 fixP->tc_fix_data = operand;
664
665 /* Don't do overflow checking if we are applying a function like
666 ha16. */
667 fixP->fx_no_overflow |= use_subexp;
668 }
669 }
670 return bits;
671 }
672
673
674 /* Detects and complains if two instructions in current_bundle write
675 to the same register, either implicitly or explicitly, or if a
676 read-only register is written. */
677 static void
678 check_illegal_reg_writes (void)
679 {
680 uint64_t all_regs_written = 0;
681 int j;
682
683 for (j = 0; j < current_bundle_index; j++)
684 {
685 const struct tilepro_instruction *instr = ¤t_bundle[j];
686 int k;
687 uint64_t regs =
688 (uint64_t) 1 << instr->opcode->implicitly_written_register;
689 uint64_t conflict;
690
691 for (k = 0; k < instr->opcode->num_operands; k++)
692 {
693 const struct tilepro_operand *operand =
694 &tilepro_operands[instr->opcode->operands[instr->pipe][k]];
695
696 if (operand->is_dest_reg)
697 {
698 int regno = instr->operand_values[k].X_add_number;
699 uint64_t mask = (uint64_t) 1 << regno;
700
701 if ((mask & ( ((uint64_t) 1 << TREG_IDN1)
702 | ((uint64_t) 1 << TREG_UDN1)
703 | ((uint64_t) 1 << TREG_UDN2)
704 | ((uint64_t) 1 << TREG_UDN3))) != 0
705 && !allow_suspicious_bundles)
706 {
707 as_bad (_("Writes to register '%s' are not allowed."),
708 tilepro_register_names[regno]);
709 }
710
711 regs |= mask;
712 }
713 }
714
715 /* Writing to the zero register doesn't count. */
716 regs &= ~((uint64_t) 1 << TREG_ZERO);
717
718 conflict = all_regs_written & regs;
719 if (conflict != 0 && !allow_suspicious_bundles)
720 {
721 /* Find which register caused the conflict. */
722 const char *conflicting_reg_name = "???";
723 int i;
724
725 for (i = 0; i < TILEPRO_NUM_REGISTERS; i++)
726 {
727 if (((conflict >> i) & 1) != 0)
728 {
729 conflicting_reg_name = tilepro_register_names[i];
730 break;
731 }
732 }
733
734 as_bad (_("Two instructions in the same bundle both write "
735 "to register %s, which is not allowed."),
736 conflicting_reg_name);
737 }
738
739 all_regs_written |= regs;
740 }
741 }
742
743
744 static void
745 tilepro_flush_bundle (void)
746 {
747 unsigned i;
748 int j, addr_mod;
749 unsigned compatible_pipes;
750 const struct bundle_template *match;
751 char *f;
752
753 inside_bundle = 0;
754
755 switch (current_bundle_index)
756 {
757 case 0:
758 /* No instructions. */
759 return;
760 case 1:
761 if (current_bundle[0].opcode->can_bundle)
762 {
763 /* Simplify later logic by adding an explicit fnop. */
764 prepend_nop_to_bundle (TILEPRO_OPC_FNOP);
765 }
766 else
767 {
768 /* This instruction cannot be bundled with anything else.
769 Prepend an explicit 'nop', rather than an 'fnop', because
770 fnops can be replaced by later binary-processing tools
771 while nops cannot. */
772 prepend_nop_to_bundle (TILEPRO_OPC_NOP);
773 }
774 break;
775 default:
776 if (!allow_suspicious_bundles)
777 {
778 /* Make sure all instructions can be bundled with other
779 instructions. */
780 const struct tilepro_opcode *cannot_bundle = NULL;
781 bool seen_non_nop = false;
782
783 for (j = 0; j < current_bundle_index; j++)
784 {
785 const struct tilepro_opcode *op = current_bundle[j].opcode;
786
787 if (!op->can_bundle && cannot_bundle == NULL)
788 cannot_bundle = op;
789 else if (op->mnemonic != TILEPRO_OPC_NOP
790 && op->mnemonic != TILEPRO_OPC_INFO
791 && op->mnemonic != TILEPRO_OPC_INFOL)
792 seen_non_nop = true;
793 }
794
795 if (cannot_bundle != NULL && seen_non_nop)
796 {
797 current_bundle_index = 0;
798 as_bad (_("'%s' may not be bundled with other instructions."),
799 cannot_bundle->name);
800 return;
801 }
802 }
803 break;
804 }
805
806 compatible_pipes =
807 BUNDLE_TEMPLATE_MASK(current_bundle[0].opcode->pipes,
808 current_bundle[1].opcode->pipes,
809 (current_bundle_index == 3
810 ? current_bundle[2].opcode->pipes
811 : (1 << NO_PIPELINE)));
812
813 /* Find a template that works, if any. */
814 match = NULL;
815 for (i = 0; i < sizeof bundle_templates / sizeof bundle_templates[0]; i++)
816 {
817 const struct bundle_template *b = &bundle_templates[i];
818 if ((b->pipe_mask & compatible_pipes) == b->pipe_mask)
819 {
820 match = b;
821 break;
822 }
823 }
824
825 if (match == NULL)
826 {
827 current_bundle_index = 0;
828 as_bad (_("Invalid combination of instructions for bundle."));
829 return;
830 }
831
832 /* If the section seems to have no alignment set yet, go ahead and
833 make it large enough to hold code. */
834 if (bfd_section_alignment (now_seg) == 0)
835 bfd_set_section_alignment (now_seg,
836 TILEPRO_LOG2_BUNDLE_ALIGNMENT_IN_BYTES);
837
838 for (j = 0; j < current_bundle_index; j++)
839 current_bundle[j].pipe = match->pipe[j];
840
841 if (current_bundle_index == 2 && !tilepro_is_x_pipeline(match->pipe[0]))
842 {
843 /* We are in Y mode with only two instructions, so add an FNOP. */
844 prepend_nop_to_bundle (TILEPRO_OPC_FNOP);
845
846 /* Figure out what pipe the fnop must be in via arithmetic.
847 * p0 + p1 + p2 must sum to the sum of TILEPRO_PIPELINE_Y[012]. */
848 current_bundle[0].pipe =
849 (tilepro_pipeline)((TILEPRO_PIPELINE_Y0
850 + TILEPRO_PIPELINE_Y1
851 + TILEPRO_PIPELINE_Y2) -
852 (current_bundle[1].pipe + current_bundle[2].pipe));
853 }
854
855 check_illegal_reg_writes ();
856
857 f = frag_more (TILEPRO_BUNDLE_SIZE_IN_BYTES);
858
859 /* Check to see if this bundle is at an offset that is a multiple of 8-bytes
860 from the start of the frag. */
861 addr_mod = frag_now_fix () & (TILEPRO_BUNDLE_ALIGNMENT_IN_BYTES - 1);
862 if (frag_now->has_code && frag_now->insn_addr != addr_mod)
863 as_bad (_("instruction address is not a multiple of 8"));
864 frag_now->insn_addr = addr_mod;
865 frag_now->has_code = 1;
866
867 tilepro_bundle_bits bits = 0;
868 for (j = 0; j < current_bundle_index; j++)
869 {
870 struct tilepro_instruction *instr = ¤t_bundle[j];
871 tilepro_pipeline pipeline = instr->pipe;
872 const struct tilepro_opcode *opcode = instr->opcode;
873
874 bits |= emit_tilepro_instruction (opcode->fixed_bit_values[pipeline],
875 opcode->num_operands,
876 &opcode->operands[pipeline][0],
877 instr->operand_values,
878 f);
879 }
880
881 number_to_chars_littleendian (f, (unsigned int)bits, 4);
882 number_to_chars_littleendian (f + 4, (unsigned int)(bits >> 32), 4);
883 current_bundle_index = 0;
884
885 /* Emit DWARF2 debugging information. */
886 dwarf2_emit_insn (TILEPRO_BUNDLE_SIZE_IN_BYTES);
887 }
888
889
890 /* Extend the expression parser to handle hi16(label), etc.
891 as well as SPR names when in the context of parsing an SPR. */
892 int
893 tilepro_parse_name (char *name, expressionS *e, char *nextcharP)
894 {
895 operatorT op = O_illegal;
896
897 if (parsing_spr)
898 {
899 void *val = str_hash_find (spr_hash, name);
900 if (val == NULL)
901 return 0;
902
903 memset (e, 0, sizeof *e);
904 e->X_op = O_constant;
905 e->X_add_number = ((const struct tilepro_spr *)val)->number;
906 return 1;
907 }
908
909 if (*nextcharP != '(')
910 {
911 /* hi16, etc. not followed by a paren is just a label with that
912 name. */
913 return 0;
914 }
915 else
916 {
917 /* Look up the operator in our table. */
918 void *val = str_hash_find (special_operator_hash, name);
919 if (val == 0)
920 return 0;
921 op = (operatorT)(long)val;
922 }
923
924 /* Restore old '(' and skip it. */
925 *input_line_pointer = '(';
926 ++input_line_pointer;
927
928 expression (e);
929
930 if (*input_line_pointer != ')')
931 {
932 as_bad (_("Missing ')'"));
933 *nextcharP = *input_line_pointer;
934 return 0;
935 }
936 /* Skip ')'. */
937 ++input_line_pointer;
938
939 if (e->X_op == O_register || e->X_op == O_absent)
940 {
941 as_bad (_("Invalid expression."));
942 e->X_op = O_constant;
943 e->X_add_number = 0;
944 }
945 else
946 {
947 /* Wrap subexpression with a unary operator. */
948 symbolS *sym = make_expr_symbol (e);
949
950 if (sym != e->X_add_symbol)
951 {
952 /* HACK: mark this symbol as a temporary wrapper around a proper
953 expression, so we can unwrap it later once we have communicated
954 the relocation type. */
955 symbol_get_value_expression (sym)->X_md = 1;
956 }
957
958 memset (e, 0, sizeof *e);
959 e->X_op = op;
960 e->X_add_symbol = sym;
961 e->X_add_number = 0;
962 }
963
964 *nextcharP = *input_line_pointer;
965 return 1;
966 }
967
968
969 /* Parses an expression which must be a register name. */
970
971 static void
972 parse_reg_expression (expressionS* expression)
973 {
974 /* Zero everything to make sure we don't miss any flags. */
975 memset (expression, 0, sizeof *expression);
976
977 char *regname;
978 char terminating_char = get_symbol_name (®name);
979
980 void* pval = str_hash_find (main_reg_hash, regname);
981
982 if (pval == NULL)
983 as_bad (_("Expected register, got '%s'."), regname);
984
985 int regno_and_flags = (int)(size_t)pval;
986 int regno = EXTRACT_REGNO(regno_and_flags);
987
988 if ((regno_and_flags & NONCANONICAL_REG_NAME_FLAG)
989 && require_canonical_reg_names)
990 as_warn (_("Found use of non-canonical register name %s; "
991 "use %s instead."),
992 regname, tilepro_register_names[regno]);
993
994 /* Restore the old character following the register name. */
995 (void) restore_line_pointer (terminating_char);
996
997 /* Fill in the expression fields to indicate it's a register. */
998 expression->X_op = O_register;
999 expression->X_add_number = regno;
1000 }
1001
1002
1003 /* Parses and type-checks comma-separated operands in input_line_pointer. */
1004 static void
1005 parse_operands (const char *opcode_name,
1006 const unsigned char *operands,
1007 int num_operands,
1008 expressionS *operand_values)
1009 {
1010 int i;
1011
1012 memset (operand_values, 0, num_operands * sizeof operand_values[0]);
1013
1014 SKIP_WHITESPACE ();
1015 for (i = 0; i < num_operands; i++)
1016 {
1017 tilepro_operand_type type = tilepro_operands[operands[i]].type;
1018
1019 SKIP_WHITESPACE ();
1020
1021 if (type == TILEPRO_OP_TYPE_REGISTER)
1022 {
1023 parse_reg_expression (&operand_values[i]);
1024 }
1025 else if (*input_line_pointer == '}')
1026 {
1027 operand_values[i].X_op = O_absent;
1028 }
1029 else if (type == TILEPRO_OP_TYPE_SPR)
1030 {
1031 /* Modify the expression parser to add SPRs to the namespace. */
1032 parsing_spr = 1;
1033 expression (&operand_values[i]);
1034 parsing_spr = 0;
1035 }
1036 else
1037 {
1038 expression (&operand_values[i]);
1039 }
1040
1041 SKIP_WHITESPACE ();
1042
1043 if (i + 1 < num_operands)
1044 {
1045 int separator = (unsigned char)*input_line_pointer++;
1046
1047 if (is_end_of_line[separator] || (separator == '}'))
1048 {
1049 as_bad (_("Too few operands to '%s'."), opcode_name);
1050 return;
1051 }
1052 else if (separator != ',')
1053 {
1054 as_bad (_("Unexpected character '%c' after operand %d to %s."),
1055 (char)separator, i + 1, opcode_name);
1056 return;
1057 }
1058 }
1059
1060 /* Arbitrarily use the first valid pipe to get the operand type,
1061 since they are all the same. */
1062 switch (tilepro_operands[operands[i]].type)
1063 {
1064 case TILEPRO_OP_TYPE_REGISTER:
1065 /* Handled in parse_reg_expression already. */
1066 break;
1067 case TILEPRO_OP_TYPE_SPR:
1068 /* Fall through */
1069 case TILEPRO_OP_TYPE_IMMEDIATE:
1070 /* Fall through */
1071 case TILEPRO_OP_TYPE_ADDRESS:
1072 if ( operand_values[i].X_op == O_register
1073 || operand_values[i].X_op == O_illegal
1074 || operand_values[i].X_op == O_absent)
1075 as_bad (_("Expected immediate expression"));
1076 break;
1077 default:
1078 abort ();
1079 }
1080 }
1081
1082 if (!is_end_of_line[(unsigned char)*input_line_pointer])
1083 {
1084 switch (*input_line_pointer)
1085 {
1086 case '}':
1087 if (!inside_bundle)
1088 as_bad (_("Found '}' when not bundling."));
1089 ++input_line_pointer;
1090 inside_bundle = 0;
1091 demand_empty_rest_of_line ();
1092 break;
1093
1094 case ',':
1095 as_bad (_("Too many operands"));
1096 break;
1097
1098 default:
1099 /* Use default error for unrecognized garbage. */
1100 demand_empty_rest_of_line ();
1101 break;
1102 }
1103 }
1104 }
1105
1106
1107 /* This is the guts of the machine-dependent assembler. STR points to a
1108 machine dependent instruction. This function is supposed to emit
1109 the frags/bytes it assembles to. */
1110 void
1111 md_assemble (char *str)
1112 {
1113 char old_char;
1114 size_t opname_len;
1115 char *old_input_line_pointer;
1116 const struct tilepro_opcode *op;
1117 int first_pipe;
1118
1119 /* Split off the opcode and look it up. */
1120 opname_len = strcspn (str, " {}");
1121 old_char = str[opname_len];
1122 str[opname_len] = '\0';
1123
1124 op = str_hash_find (op_hash, str);
1125 str[opname_len] = old_char;
1126 if (op == NULL)
1127 {
1128 as_bad (_("Unknown opcode `%.*s'."), (int)opname_len, str);
1129 return;
1130 }
1131
1132 /* Prepare to parse the operands. */
1133 old_input_line_pointer = input_line_pointer;
1134 input_line_pointer = str + opname_len;
1135 SKIP_WHITESPACE ();
1136
1137 if (current_bundle_index == TILEPRO_MAX_INSTRUCTIONS_PER_BUNDLE)
1138 {
1139 as_bad (_("Too many instructions for bundle."));
1140 tilepro_flush_bundle ();
1141 }
1142
1143 /* Make sure we have room for the upcoming bundle before we
1144 create any fixups. Otherwise if we have to switch to a new
1145 frag the fixup dot_value fields will be wrong. */
1146 frag_grow (TILEPRO_BUNDLE_SIZE_IN_BYTES);
1147
1148 /* Find a valid pipe for this opcode. */
1149 for (first_pipe = 0; (op->pipes & (1 << first_pipe)) == 0; first_pipe++)
1150 ;
1151
1152 /* Call the function that assembles this instruction. */
1153 current_bundle[current_bundle_index].opcode = op;
1154 parse_operands (op->name,
1155 &op->operands[first_pipe][0],
1156 op->num_operands,
1157 current_bundle[current_bundle_index].operand_values);
1158 ++current_bundle_index;
1159
1160 /* Restore the saved value of input_line_pointer. */
1161 input_line_pointer = old_input_line_pointer;
1162
1163 /* If we weren't inside curly braces, go ahead and emit
1164 this lone instruction as a bundle right now. */
1165 if (!inside_bundle)
1166 tilepro_flush_bundle ();
1167 }
1168
1169 static void
1170 s_require_canonical_reg_names (int require)
1171 {
1172 demand_empty_rest_of_line ();
1173 require_canonical_reg_names = require;
1174 }
1175
1176 static void
1177 s_allow_suspicious_bundles (int allow)
1178 {
1179 demand_empty_rest_of_line ();
1180 allow_suspicious_bundles = allow;
1181 }
1182
1183 const pseudo_typeS md_pseudo_table[] =
1184 {
1185 {"align", s_align_bytes, 0}, /* Defaulting is invalid (0). */
1186 {"word", cons, 4},
1187 {"require_canonical_reg_names", s_require_canonical_reg_names, 1 },
1188 {"no_require_canonical_reg_names", s_require_canonical_reg_names, 0 },
1189 {"allow_suspicious_bundles", s_allow_suspicious_bundles, 1 },
1190 {"no_allow_suspicious_bundles", s_allow_suspicious_bundles, 0 },
1191 { NULL, 0, 0 }
1192 };
1193
1194 /* Turn the string pointed to by litP into a floating point constant
1195 of type TYPE, and emit the appropriate bytes. The number of
1196 LITTLENUMS emitted is stored in *SIZEP. An error message is
1197 returned, or NULL on OK. */
1198
1199 const char *
1200 md_atof (int type, char *litP, int *sizeP)
1201 {
1202 int prec;
1203 LITTLENUM_TYPE words[MAX_LITTLENUMS];
1204 LITTLENUM_TYPE *wordP;
1205 char *t;
1206
1207 switch (type)
1208 {
1209 case 'f':
1210 case 'F':
1211 prec = 2;
1212 break;
1213
1214 case 'd':
1215 case 'D':
1216 prec = 4;
1217 break;
1218
1219 default:
1220 *sizeP = 0;
1221 return _("Bad call to md_atof ()");
1222 }
1223 t = atof_ieee (input_line_pointer, type, words);
1224 if (t)
1225 input_line_pointer = t;
1226
1227 *sizeP = prec * sizeof (LITTLENUM_TYPE);
1228 /* This loops outputs the LITTLENUMs in REVERSE order; in accord with
1229 the bigendian 386. */
1230 for (wordP = words + prec - 1; prec--;)
1231 {
1232 md_number_to_chars (litP, (valueT) (*wordP--), sizeof (LITTLENUM_TYPE));
1233 litP += sizeof (LITTLENUM_TYPE);
1234 }
1235 return 0;
1236 }
1237
1238
1239 /* We have no need to default values of symbols. */
1240
1241 symbolS *
1242 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
1243 {
1244 return NULL;
1245 }
1246
1247
1248 void
1249 tilepro_cons_fix_new (fragS *frag,
1250 int where,
1251 int nbytes,
1252 expressionS *exp)
1253 {
1254 expressionS subexp;
1255 bfd_reloc_code_real_type reloc = BFD_RELOC_NONE;
1256 int no_overflow = 0;
1257 fixS *fixP;
1258
1259 /* See if it's one of our special functions. */
1260 switch (exp->X_op)
1261 {
1262 case O_lo16:
1263 reloc = BFD_RELOC_LO16;
1264 no_overflow = 1;
1265 break;
1266 case O_hi16:
1267 reloc = BFD_RELOC_HI16;
1268 no_overflow = 1;
1269 break;
1270 case O_ha16:
1271 reloc = BFD_RELOC_HI16_S;
1272 no_overflow = 1;
1273 break;
1274
1275 default:
1276 /* Do nothing. */
1277 break;
1278 }
1279
1280 if (reloc != BFD_RELOC_NONE)
1281 {
1282 if (nbytes != 2)
1283 {
1284 as_bad (_("This operator only produces two byte values."));
1285 nbytes = 2;
1286 }
1287
1288 memset (&subexp, 0, sizeof subexp);
1289 subexp.X_op = O_symbol;
1290 subexp.X_add_symbol = exp->X_add_symbol;
1291 exp = &subexp;
1292 }
1293 else
1294 {
1295 switch (nbytes)
1296 {
1297 case 1:
1298 reloc = BFD_RELOC_8;
1299 break;
1300 case 2:
1301 reloc = BFD_RELOC_16;
1302 break;
1303 case 4:
1304 reloc = BFD_RELOC_32;
1305 break;
1306 case 8:
1307 reloc = BFD_RELOC_64;
1308 break;
1309 default:
1310 as_bad (_("unsupported BFD relocation size %d"), nbytes);
1311 reloc = BFD_RELOC_32;
1312 break;
1313 }
1314 }
1315
1316 fixP = fix_new_exp (frag, where, nbytes, exp, 0, reloc);
1317 fixP->tc_fix_data = NULL;
1318 fixP->fx_no_overflow |= no_overflow;
1319 }
1320
1321
1322 void
1323 md_apply_fix (fixS *fixP, valueT * valP, segT seg ATTRIBUTE_UNUSED)
1324 {
1325 const struct tilepro_operand *operand;
1326 valueT value = *valP;
1327 char *p;
1328
1329 /* Leave these for the linker. */
1330 if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
1331 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
1332 return;
1333
1334 if (fixP->fx_subsy != (symbolS *) NULL)
1335 {
1336 /* We can't actually support subtracting a symbol. */
1337 as_bad_subtract (fixP);
1338 }
1339
1340 /* Correct relocation types for pc-relativeness. */
1341 switch (fixP->fx_r_type)
1342 {
1343 #define FIX_PCREL(rtype) \
1344 case rtype: \
1345 if (fixP->fx_pcrel) \
1346 fixP->fx_r_type = rtype##_PCREL; \
1347 break; \
1348 \
1349 case rtype##_PCREL: \
1350 if (!fixP->fx_pcrel) \
1351 fixP->fx_r_type = rtype; \
1352 break
1353
1354 FIX_PCREL (BFD_RELOC_8);
1355 FIX_PCREL (BFD_RELOC_16);
1356 FIX_PCREL (BFD_RELOC_32);
1357 FIX_PCREL (BFD_RELOC_TILEPRO_IMM16_X0);
1358 FIX_PCREL (BFD_RELOC_TILEPRO_IMM16_X1);
1359 FIX_PCREL (BFD_RELOC_TILEPRO_IMM16_X0_LO);
1360 FIX_PCREL (BFD_RELOC_TILEPRO_IMM16_X1_LO);
1361 FIX_PCREL (BFD_RELOC_TILEPRO_IMM16_X0_HI);
1362 FIX_PCREL (BFD_RELOC_TILEPRO_IMM16_X1_HI);
1363 FIX_PCREL (BFD_RELOC_TILEPRO_IMM16_X0_HA);
1364 FIX_PCREL (BFD_RELOC_TILEPRO_IMM16_X1_HA);
1365
1366 #undef FIX_PCREL
1367
1368 default:
1369 /* Do nothing */
1370 break;
1371 }
1372
1373 if (fixP->fx_addsy != NULL)
1374 {
1375 #ifdef OBJ_ELF
1376 switch (fixP->fx_r_type)
1377 {
1378 case BFD_RELOC_TILEPRO_IMM8_X0_TLS_GD_ADD:
1379 case BFD_RELOC_TILEPRO_IMM8_X1_TLS_GD_ADD:
1380 case BFD_RELOC_TILEPRO_IMM8_Y0_TLS_GD_ADD:
1381 case BFD_RELOC_TILEPRO_IMM8_Y1_TLS_GD_ADD:
1382 case BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD:
1383 case BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD:
1384 case BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_LO:
1385 case BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_LO:
1386 case BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_HI:
1387 case BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_HI:
1388 case BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_HA:
1389 case BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_HA:
1390 case BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE:
1391 case BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE:
1392 case BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_LO:
1393 case BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_LO:
1394 case BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_HI:
1395 case BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_HI:
1396 case BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_HA:
1397 case BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_HA:
1398 case BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE:
1399 case BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE:
1400 case BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_LO:
1401 case BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_LO:
1402 case BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_HI:
1403 case BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_HI:
1404 case BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_HA:
1405 case BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_HA:
1406 case BFD_RELOC_TILEPRO_TLS_GD_CALL:
1407 case BFD_RELOC_TILEPRO_TLS_IE_LOAD:
1408 case BFD_RELOC_TILEPRO_TLS_DTPMOD32:
1409 case BFD_RELOC_TILEPRO_TLS_DTPOFF32:
1410 case BFD_RELOC_TILEPRO_TLS_TPOFF32:
1411 S_SET_THREAD_LOCAL (fixP->fx_addsy);
1412 break;
1413
1414 default:
1415 /* Do nothing */
1416 break;
1417 }
1418 #endif
1419 return;
1420 }
1421
1422 /* Apply lo16, hi16, ha16, etc. munging. */
1423 switch (fixP->fx_r_type)
1424 {
1425 case BFD_RELOC_LO16:
1426 case BFD_RELOC_TILEPRO_IMM16_X0_LO:
1427 case BFD_RELOC_TILEPRO_IMM16_X1_LO:
1428 case BFD_RELOC_TILEPRO_IMM16_X0_LO_PCREL:
1429 case BFD_RELOC_TILEPRO_IMM16_X1_LO_PCREL:
1430 *valP = value = apply_special_operator (O_lo16, value);
1431 break;
1432
1433 case BFD_RELOC_HI16:
1434 case BFD_RELOC_TILEPRO_IMM16_X0_HI:
1435 case BFD_RELOC_TILEPRO_IMM16_X1_HI:
1436 case BFD_RELOC_TILEPRO_IMM16_X0_HI_PCREL:
1437 case BFD_RELOC_TILEPRO_IMM16_X1_HI_PCREL:
1438 *valP = value = apply_special_operator (O_hi16, value);
1439 break;
1440
1441 case BFD_RELOC_HI16_S:
1442 case BFD_RELOC_TILEPRO_IMM16_X0_HA:
1443 case BFD_RELOC_TILEPRO_IMM16_X1_HA:
1444 case BFD_RELOC_TILEPRO_IMM16_X0_HA_PCREL:
1445 case BFD_RELOC_TILEPRO_IMM16_X1_HA_PCREL:
1446 *valP = value = apply_special_operator (O_ha16, value);
1447 break;
1448
1449 default:
1450 /* Do nothing */
1451 break;
1452 }
1453
1454 p = fixP->fx_frag->fr_literal + fixP->fx_where;
1455
1456 operand = fixP->tc_fix_data;
1457 if (operand != NULL)
1458 {
1459 /* It's an instruction operand. */
1460 tilepro_bundle_bits bits =
1461 insert_operand (0, operand, value, fixP->fx_file, fixP->fx_line);
1462
1463 /* Note that we might either be writing out bits for a bundle or a
1464 static network instruction, which are different sizes, so it's
1465 important to stop touching memory once we run out of bits. ORing in
1466 values is OK since we know the existing bits for this operand are
1467 zero. */
1468 for (; bits != 0; bits >>= 8)
1469 *p++ |= (char)bits;
1470 }
1471 else
1472 {
1473 /* Some other kind of relocation. */
1474 switch (fixP->fx_r_type)
1475 {
1476 case BFD_RELOC_8:
1477 case BFD_RELOC_8_PCREL:
1478 md_number_to_chars (p, value, 1);
1479 break;
1480
1481 case BFD_RELOC_16:
1482 case BFD_RELOC_16_PCREL:
1483 md_number_to_chars (p, value, 2);
1484 break;
1485
1486 case BFD_RELOC_32:
1487 case BFD_RELOC_32_PCREL:
1488 md_number_to_chars (p, value, 4);
1489 break;
1490
1491 default:
1492 /* Leave it for the linker. */
1493 return;
1494 }
1495 }
1496
1497 fixP->fx_done = 1;
1498 }
1499
1500
1501 /* Generate the BFD reloc to be stuck in the object file from the
1502 fixup used internally in the assembler. */
1503
1504 arelent *
1505 tc_gen_reloc (asection *sec ATTRIBUTE_UNUSED, fixS *fixp)
1506 {
1507 arelent *reloc;
1508
1509 reloc = XNEW (arelent);
1510 reloc->sym_ptr_ptr = XNEW (asymbol *);
1511 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1512 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
1513
1514 /* Make sure none of our internal relocations make it this far.
1515 They'd better have been fully resolved by this point. */
1516 gas_assert ((int) fixp->fx_r_type > 0);
1517
1518 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
1519 if (reloc->howto == NULL)
1520 {
1521 as_bad_where (fixp->fx_file, fixp->fx_line,
1522 _("cannot represent `%s' relocation in object file"),
1523 bfd_get_reloc_code_name (fixp->fx_r_type));
1524 return NULL;
1525 }
1526
1527 if (!fixp->fx_pcrel != !reloc->howto->pc_relative)
1528 {
1529 as_fatal (_("internal error? cannot generate `%s' relocation (%d, %d)"),
1530 bfd_get_reloc_code_name (fixp->fx_r_type),
1531 fixp->fx_pcrel, reloc->howto->pc_relative);
1532 }
1533 gas_assert (!fixp->fx_pcrel == !reloc->howto->pc_relative);
1534
1535 reloc->addend = fixp->fx_offset;
1536
1537 return reloc;
1538 }
1539
1540
1541 /* The location from which a PC relative jump should be calculated,
1542 given a PC relative reloc. */
1543
1544 long
1545 md_pcrel_from (fixS *fixP)
1546 {
1547 return fixP->fx_frag->fr_address + fixP->fx_where;
1548 }
1549
1550
1551 /* Return 1 if it's OK to adjust a reloc by replacing the symbol with
1552 a section symbol plus some offset. */
1553 int
1554 tilepro_fix_adjustable (fixS *fix)
1555 {
1556 /* Prevent all adjustments to global symbols */
1557 if (S_IS_EXTERNAL (fix->fx_addsy) || S_IS_WEAK (fix->fx_addsy))
1558 return 0;
1559
1560 return 1;
1561 }
1562
1563
1564 int
1565 tilepro_unrecognized_line (int ch)
1566 {
1567 switch (ch)
1568 {
1569 case '{':
1570 if (inside_bundle)
1571 {
1572 as_bad (_("Found '{' when already bundling."));
1573 }
1574 else
1575 {
1576 inside_bundle = 1;
1577 current_bundle_index = 0;
1578 }
1579 return 1;
1580
1581 case '}':
1582 if (!inside_bundle)
1583 {
1584 as_bad (_("Found '}' when not bundling."));
1585 }
1586 else
1587 {
1588 tilepro_flush_bundle ();
1589 }
1590
1591 /* Allow '{' to follow on the same line. We also allow ";;", but that
1592 happens automatically because ';' is an end of line marker. */
1593 SKIP_WHITESPACE ();
1594 if (input_line_pointer[0] == '{')
1595 {
1596 input_line_pointer++;
1597 return tilepro_unrecognized_line ('{');
1598 }
1599
1600 demand_empty_rest_of_line ();
1601 return 1;
1602
1603 default:
1604 break;
1605 }
1606
1607 /* Not a valid line. */
1608 return 0;
1609 }
1610
1611
1612 /* This is called from HANDLE_ALIGN in write.c. Fill in the contents
1613 of an rs_align_code fragment. */
1614
1615 void
1616 tilepro_handle_align (fragS *fragp)
1617 {
1618 int bytes, fix;
1619 char *p;
1620
1621 if (fragp->fr_type != rs_align_code)
1622 return;
1623
1624 bytes = fragp->fr_next->fr_address - fragp->fr_address - fragp->fr_fix;
1625 p = fragp->fr_literal + fragp->fr_fix;
1626 fix = 0;
1627
1628 /* Determine the bits for NOP. */
1629 const struct tilepro_opcode *nop_opcode =
1630 &tilepro_opcodes[TILEPRO_OPC_NOP];
1631 tilepro_bundle_bits nop =
1632 ( nop_opcode->fixed_bit_values[TILEPRO_PIPELINE_X0]
1633 | nop_opcode->fixed_bit_values[TILEPRO_PIPELINE_X1]);
1634
1635 if ((bytes & (TILEPRO_BUNDLE_SIZE_IN_BYTES - 1)) != 0)
1636 {
1637 fix = bytes & (TILEPRO_BUNDLE_SIZE_IN_BYTES - 1);
1638 memset (p, 0, fix);
1639 p += fix;
1640 bytes -= fix;
1641 }
1642
1643 number_to_chars_littleendian (p, (unsigned int)nop, 4);
1644 number_to_chars_littleendian (p + 4, (unsigned int)(nop >> 32), 4);
1645 fragp->fr_fix += fix;
1646 fragp->fr_var = TILEPRO_BUNDLE_SIZE_IN_BYTES;
1647 }
1648
1649 /* Standard calling conventions leave the CFA at SP on entry. */
1650 void
1651 tilepro_cfi_frame_initial_instructions (void)
1652 {
1653 cfi_add_CFA_def_cfa_register (54);
1654 }
1655
1656 int
1657 tc_tilepro_regname_to_dw2regnum (char *regname)
1658 {
1659 int i;
1660
1661 for (i = 0; i < TILEPRO_NUM_REGISTERS; i++)
1662 {
1663 if (!strcmp (regname, tilepro_register_names[i]))
1664 return i;
1665 }
1666
1667 return -1;
1668 }