projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gas/
[deliverable/binutils-gdb.git] / gas / config / tc-nios2.c
CommitLineData
36591ba1
SL		 1/* Altera Nios II assembler.
2 Copyright (C) 2012, 2013 Free Software Foundation, Inc.
3 Contributed by Nigel Gray (ngray@altera.com).
4 Contributed by Mentor Graphics, Inc.
5
6 This file is part of GAS, the GNU Assembler.
7
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
12
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
22
23#include "as.h"
24#include "opcode/nios2.h"
25#include "elf/nios2.h"
26#include "tc-nios2.h"
27#include "bfd.h"
28#include "dwarf2dbg.h"
29#include "subsegs.h"
30#include "safe-ctype.h"
31#include "dw2gencfi.h"
32
33#ifndef OBJ_ELF
34/* We are not supporting any other target so we throw a compile time error. */
35OBJ_ELF not defined
36#endif
37
38/* We can choose our endianness at run-time, regardless of configuration. */
39extern int target_big_endian;
40
41/* This array holds the chars that always start a comment. If the
42 pre-processor is disabled, these aren't very useful. */
43const char comment_chars[] = "#";
44
45/* This array holds the chars that only start a comment at the beginning of
46 a line. If the line seems to have the form '# 123 filename'
47 .line and .file directives will appear in the pre-processed output. */
48/* Note that input_file.c hand checks for '#' at the beginning of the
49 first line of the input file. This is because the compiler outputs
50 #NO_APP at the beginning of its output. */
51/* Also note that C style comments are always supported. */
52const char line_comment_chars[] = "#";
53
54/* This array holds machine specific line separator characters. */
55const char line_separator_chars[] = ";";
56
57/* Chars that can be used to separate mant from exp in floating point nums. */
58const char EXP_CHARS[] = "eE";
59
60/* Chars that mean this number is a floating point constant. */
61/* As in 0f12.456 */
62/* or 0d1.2345e12 */
63const char FLT_CHARS[] = "rRsSfFdDxXpP";
64
65/* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
66 changed in read.c. Ideally it shouldn't have to know about it at all,
67 but nothing is ideal around here. */
68
69/* Machine-dependent command-line options. */
70
71const char *md_shortopts = "r";
72
73struct option md_longopts[] = {
74#define OPTION_RELAX_ALL (OPTION_MD_BASE + 0)
75 {"relax-all", no_argument, NULL, OPTION_RELAX_ALL},
76#define OPTION_NORELAX (OPTION_MD_BASE + 1)
77 {"no-relax", no_argument, NULL, OPTION_NORELAX},
78#define OPTION_RELAX_SECTION (OPTION_MD_BASE + 2)
79 {"relax-section", no_argument, NULL, OPTION_RELAX_SECTION},
80#define OPTION_EB (OPTION_MD_BASE + 3)
81 {"EB", no_argument, NULL, OPTION_EB},
82#define OPTION_EL (OPTION_MD_BASE + 4)
83 {"EL", no_argument, NULL, OPTION_EL}
84};
85
86size_t md_longopts_size = sizeof (md_longopts);
87
88/* The assembler supports three different relaxation modes, controlled by
89 command-line options. */
90typedef enum
91{
92 relax_section = 0,
93 relax_none,
94 relax_all
95} relax_optionT;
96
97/* Struct contains all assembler options set with .set. */
98struct
99{
100 /* .set noat -> noat = 1 allows assembly code to use at without warning
101 and macro expansions generate a warning.
102 .set at -> noat = 0, assembly code using at warn but macro expansions
103 do not generate warnings. */
104 bfd_boolean noat;
105
106 /* .set nobreak -> nobreak = 1 allows assembly code to use ba,bt without
107 warning.
108 .set break -> nobreak = 0, assembly code using ba,bt warns. */
109 bfd_boolean nobreak;
110
111 /* .cmd line option -relax-all allows all branches and calls to be replaced
112 with longer versions.
113 -no-relax inhibits branch/call conversion.
114 The default value is relax_section, which relaxes branches within
115 a section. */
116 relax_optionT relax;
117
118} nios2_as_options = {FALSE, FALSE, relax_section};
119
120
121typedef struct nios2_insn_reloc
122{
123 /* Any expression in the instruction is parsed into this field,
124 which is passed to fix_new_exp() to generate a fixup. */
125 expressionS reloc_expression;
126
127 /* The type of the relocation to be applied. */
128 bfd_reloc_code_real_type reloc_type;
129
130 /* PC-relative. */
131 unsigned int reloc_pcrel;
132
133 /* The next relocation to be applied to the instruction. */
134 struct nios2_insn_reloc *reloc_next;
135} nios2_insn_relocS;
136
137/* This struct is used to hold state when assembling instructions. */
138typedef struct nios2_insn_info
139{
140 /* Assembled instruction. */
141 unsigned long insn_code;
142 /* Pointer to the relevant bit of the opcode table. */
143 const struct nios2_opcode *insn_nios2_opcode;
144 /* After parsing ptrs to the tokens in the instruction fill this array
145 it is terminated with a null pointer (hence the first +1).
146 The second +1 is because in some parts of the code the opcode
147 is not counted as a token, but still placed in this array. */
148 const char *insn_tokens[NIOS2_MAX_INSN_TOKENS + 1 + 1];
149
150 /* This holds information used to generate fixups
151 and eventually relocations if it is not null. */
152 nios2_insn_relocS *insn_reloc;
153} nios2_insn_infoS;
154
155/* This struct associates an argument assemble function with
156 an argument syntax string. Used by the assembler to find out
157 how to parse and assemble a set of instruction operands and
158 return the instruction field values. */
159typedef struct nios2_arg_info
160{
161 const char *args;
162 void (*assemble_args_func) (nios2_insn_infoS *insn_info);
163} nios2_arg_infoS;
164
165/* This struct is used to convert Nios II pseudo-ops into the
166 corresponding real op. */
167typedef struct nios2_ps_insn_info
168{
169 /* Map this pseudo_op... */
170 const char *pseudo_insn;
171
172 /* ...to this real instruction. */
173 const char *insn;
174
175 /* Call this function to modify the operands.... */
176 void (*arg_modifer_func) (char ** parsed_args, const char *arg, int num,
177 int start);
178
179 /* ...with these arguments. */
180 const char *arg_modifier;
181 int num;
182 int index;
183
184 /* If arg_modifier_func allocates new memory, provide this function
185 to free it afterwards. */
186 void (*arg_cleanup_func) (char **parsed_args, int num, int start);
187} nios2_ps_insn_infoS;
188
189/* Opcode hash table. */
190static struct hash_control *nios2_opcode_hash = NULL;
191#define nios2_opcode_lookup(NAME) \
192 ((struct nios2_opcode *) hash_find (nios2_opcode_hash, (NAME)))
193
194/* Register hash table. */
195static struct hash_control *nios2_reg_hash = NULL;
196#define nios2_reg_lookup(NAME) \
197 ((struct nios2_reg *) hash_find (nios2_reg_hash, (NAME)))
198
199/* Parse args hash table. */
200static struct hash_control *nios2_arg_hash = NULL;
201#define nios2_arg_lookup(NAME) \
202 ((nios2_arg_infoS *) hash_find (nios2_arg_hash, (NAME)))
203
204/* Pseudo-op hash table. */
205static struct hash_control *nios2_ps_hash = NULL;
206#define nios2_ps_lookup(NAME) \
207 ((nios2_ps_insn_infoS *) hash_find (nios2_ps_hash, (NAME)))
208
209/* The known current alignment of the current section. */
210static int nios2_current_align;
211static segT nios2_current_align_seg;
212
213static int nios2_auto_align_on = 1;
214
215/* The last seen label in the current section. This is used to auto-align
216 labels preceeding instructions. */
217static symbolS *nios2_last_label;
218
219#ifdef OBJ_ELF
220/* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
221symbolS *GOT_symbol;
222#endif
223
224\f
225/** Utility routines. */
226/* Function md_chars_to_number takes the sequence of
227 bytes in buf and returns the corresponding value
228 in an int. n must be 1, 2 or 4. */
229static valueT
230md_chars_to_number (char *buf, int n)
231{
232 int i;
233 valueT val;
234
235 gas_assert (n == 1 || n == 2 || n == 4);
236
237 val = 0;
238 if (target_big_endian)
239 for (i = 0; i < n; ++i)
240 val = val | ((buf[i] & 0xff) << 8 * (n - (i + 1)));
241 else
242 for (i = 0; i < n; ++i)
243 val = val | ((buf[i] & 0xff) << 8 * i);
244 return val;
245}
246
247
248/* This function turns a C long int, short int or char
249 into the series of bytes that represent the number
250 on the target machine. */
251void
252md_number_to_chars (char *buf, valueT val, int n)
253{
254 gas_assert (n == 1 || n == 2 || n == 4 || n == 8);
255 if (target_big_endian)
256 number_to_chars_bigendian (buf, val, n);
257 else
258 number_to_chars_littleendian (buf, val, n);
259}
260
261/* Turn a string in input_line_pointer into a floating point constant
262 of type TYPE, and store the appropriate bytes in *LITP. The number
263 of LITTLENUMS emitted is stored in *SIZEP. An error message is
264 returned, or NULL on OK. */
265char *
266md_atof (int type, char *litP, int *sizeP)
267{
268 int prec;
269 LITTLENUM_TYPE words[4];
270 char *t;
271 int i;
272
273 switch (type)
274 {
275 case 'f':
276 prec = 2;
277 break;
278 case 'd':
279 prec = 4;
280 break;
281 default:
282 *sizeP = 0;
283 return _("bad call to md_atof");
284 }
285
286 t = atof_ieee (input_line_pointer, type, words);
287 if (t)
288 input_line_pointer = t;
289
290 *sizeP = prec * 2;
291
292 if (! target_big_endian)
293 for (i = prec - 1; i >= 0; i--, litP += 2)
294 md_number_to_chars (litP, (valueT) words[i], 2);
295 else
296 for (i = 0; i < prec; i++, litP += 2)
297 md_number_to_chars (litP, (valueT) words[i], 2);
298
299 return NULL;
300}
301
302/* Return true if STR starts with PREFIX, which should be a string literal. */
303#define strprefix(STR, PREFIX) \
304 (strncmp ((STR), PREFIX, strlen (PREFIX)) == 0)
305
306/* Return true if STR is prefixed with a control register name. */
307static int
308nios2_control_register_arg_p (const char *str)
309{
310 return (strprefix (str, "ctl")
311 || strprefix (str, "cpuid")
312 || strprefix (str, "status")
313 || strprefix (str, "estatus")
314 || strprefix (str, "bstatus")
315 || strprefix (str, "ienable")
316 || strprefix (str, "ipending")
317 || strprefix (str, "exception")
318 || strprefix (str, "pteaddr")
319 || strprefix (str, "tlbacc")
320 || strprefix (str, "tlbmisc")
e3031850 321 || strprefix (str, "eccinj")
36591ba1
SL		 322 || strprefix (str, "config")
323 || strprefix (str, "mpubase")
324 || strprefix (str, "mpuacc")
325 || strprefix (str, "badaddr"));
326}
327
328/* Return true if STR is prefixed with a special relocation operator. */
329static int
330nios2_special_relocation_p (const char *str)
331{
332 return (strprefix (str, "%lo")
333 || strprefix (str, "%hi")
334 || strprefix (str, "%hiadj")
335 || strprefix (str, "%gprel")
336 || strprefix (str, "%got")
337 || strprefix (str, "%call")
338 || strprefix (str, "%gotoff_lo")
339 || strprefix (str, "%gotoff_hiadj")
340 || strprefix (str, "%tls_gd")
341 || strprefix (str, "%tls_ldm")
342 || strprefix (str, "%tls_ldo")
343 || strprefix (str, "%tls_ie")
344 || strprefix (str, "%tls_le")
345 || strprefix (str, "%gotoff"));
346}
347
348/* Checks whether the register name is a coprocessor
349 register - returns TRUE if it is, FALSE otherwise. */
350static bfd_boolean
351nios2_coproc_reg (const char *reg_name)
352{
353 gas_assert (reg_name != NULL);
354
355 /* Check that we do have a valid register name and that it is a
356 coprocessor register.
357 It must begin with c, not be a control register, and be a valid
358 register name. */
359 if (strprefix (reg_name, "c")
360 && !strprefix (reg_name, "ctl")
361 && hash_find (nios2_reg_hash, reg_name) != NULL)
362 return TRUE;
363 else
364 return FALSE;
365}
366
367/* nop fill pattern for text section. */
368static char const nop[4] = { 0x3a, 0x88, 0x01, 0x00 };
369
370/* Handles all machine-dependent alignment needs. */
371static void
372nios2_align (int log_size, const char *pfill, symbolS *label)
373{
374 int align;
375 long max_alignment = 15;
376
377 /* The front end is prone to changing segments out from under us
378 temporarily when -g is in effect. */
379 int switched_seg_p = (nios2_current_align_seg != now_seg);
380
381 align = log_size;
382 if (align > max_alignment)
383 {
384 align = max_alignment;
385 as_bad (_("Alignment too large: %d. assumed"), align);
386 }
387 else if (align < 0)
388 {
389 as_warn (_("Alignment negative: 0 assumed"));
390 align = 0;
391 }
392
393 if (align != 0)
394 {
395 if (subseg_text_p (now_seg) && align >= 2)
396 {
397 /* First, make sure we're on a four-byte boundary, in case
398 someone has been putting .byte values the text section. */
399 if (nios2_current_align < 2 || switched_seg_p)
400 frag_align (2, 0, 0);
401
402 /* Now fill in the alignment pattern. */
403 if (pfill != NULL)
404 frag_align_pattern (align, pfill, sizeof nop, 0);
405 else
406 frag_align (align, 0, 0);
407 }
408 else
409 frag_align (align, 0, 0);
410
411 if (!switched_seg_p)
412 nios2_current_align = align;
413
414 /* If the last label was in a different section we can't align it. */
415 if (label != NULL && !switched_seg_p)
416 {
417 symbolS *sym;
418 int label_seen = FALSE;
419 struct frag *old_frag;
420 valueT old_value;
421 valueT new_value;
422
423 gas_assert (S_GET_SEGMENT (label) == now_seg);
424
425 old_frag = symbol_get_frag (label);
426 old_value = S_GET_VALUE (label);
427 new_value = (valueT) frag_now_fix ();
428
429 /* It is possible to have more than one label at a particular
430 address, especially if debugging is enabled, so we must
431 take care to adjust all the labels at this address in this
432 fragment. To save time we search from the end of the symbol
433 list, backwards, since the symbols we are interested in are
434 almost certainly the ones that were most recently added.
435 Also to save time we stop searching once we have seen at least
436 one matching label, and we encounter a label that is no longer
437 in the target fragment. Note, this search is guaranteed to
438 find at least one match when sym == label, so no special case
439 code is necessary. */
440 for (sym = symbol_lastP; sym != NULL; sym = symbol_previous (sym))
441 if (symbol_get_frag (sym) == old_frag
442 && S_GET_VALUE (sym) == old_value)
443 {
444 label_seen = TRUE;
445 symbol_set_frag (sym, frag_now);
446 S_SET_VALUE (sym, new_value);
447 }
448 else if (label_seen && symbol_get_frag (sym) != old_frag)
449 break;
450 }
451 record_alignment (now_seg, align);
452 }
453}
454
455\f
456/** Support for self-check mode. */
457
458/* Mode of the assembler. */
459typedef enum
460{
461 NIOS2_MODE_ASSEMBLE, /* Ordinary operation. */
462 NIOS2_MODE_TEST /* Hidden mode used for self testing. */
463} NIOS2_MODE;
464
465static NIOS2_MODE nios2_mode = NIOS2_MODE_ASSEMBLE;
466
467/* This function is used to in self-checking mode
468 to check the assembled instruction
469 opcode should be the assembled opcode, and exp_opcode
470 the parsed string representing the expected opcode. */
471static void
472nios2_check_assembly (unsigned int opcode, const char *exp_opcode)
473{
474 if (nios2_mode == NIOS2_MODE_TEST)
475 {
476 if (exp_opcode == NULL)
477 as_bad (_("expecting opcode string in self test mode"));
478 else if (opcode != strtoul (exp_opcode, NULL, 16))
479 as_bad (_("assembly 0x%08x, expected %s"), opcode, exp_opcode);
480 }
481}
482
483\f
484/** Support for machine-dependent assembler directives. */
485/* Handle the .align pseudo-op. This aligns to a power of two. It
486 also adjusts any current instruction label. We treat this the same
487 way the MIPS port does: .align 0 turns off auto alignment. */
488static void
489s_nios2_align (int ignore ATTRIBUTE_UNUSED)
490{
491 int align;
492 char fill;
493 const char *pfill = NULL;
494 long max_alignment = 15;
495
496 align = get_absolute_expression ();
497 if (align > max_alignment)
498 {
499 align = max_alignment;
500 as_bad (_("Alignment too large: %d. assumed"), align);
501 }
502 else if (align < 0)
503 {
504 as_warn (_("Alignment negative: 0 assumed"));
505 align = 0;
506 }
507
508 if (*input_line_pointer == ',')
509 {
510 input_line_pointer++;
511 fill = get_absolute_expression ();
512 pfill = (const char *) &fill;
513 }
514 else if (subseg_text_p (now_seg))
515 pfill = (const char *) &nop;
516 else
517 {
518 pfill = NULL;
519 nios2_last_label = NULL;
520 }
521
522 if (align != 0)
523 {
524 nios2_auto_align_on = 1;
525 nios2_align (align, pfill, nios2_last_label);
526 nios2_last_label = NULL;
527 }
528 else
529 nios2_auto_align_on = 0;
530
531 demand_empty_rest_of_line ();
532}
533
534/* Handle the .text pseudo-op. This is like the usual one, but it
535 clears the saved last label and resets known alignment. */
536static void
537s_nios2_text (int i)
538{
539 s_text (i);
540 nios2_last_label = NULL;
541 nios2_current_align = 0;
542 nios2_current_align_seg = now_seg;
543}
544
545/* Handle the .data pseudo-op. This is like the usual one, but it
546 clears the saved last label and resets known alignment. */
547static void
548s_nios2_data (int i)
549{
550 s_data (i);
551 nios2_last_label = NULL;
552 nios2_current_align = 0;
553 nios2_current_align_seg = now_seg;
554}
555
556/* Handle the .section pseudo-op. This is like the usual one, but it
557 clears the saved last label and resets known alignment. */
558static void
559s_nios2_section (int ignore)
560{
561 obj_elf_section (ignore);
562 nios2_last_label = NULL;
563 nios2_current_align = 0;
564 nios2_current_align_seg = now_seg;
565}
566
567/* Explicitly unaligned cons. */
568static void
569s_nios2_ucons (int nbytes)
570{
571 int hold;
572 hold = nios2_auto_align_on;
573 nios2_auto_align_on = 0;
574 cons (nbytes);
575 nios2_auto_align_on = hold;
576}
577
578/* Handle the .sdata directive. */
579static void
580s_nios2_sdata (int ignore ATTRIBUTE_UNUSED)
581{
582 get_absolute_expression (); /* Ignored. */
583 subseg_new (".sdata", 0);
584 demand_empty_rest_of_line ();
585}
586
587/* .set sets assembler options eg noat/at and is also used
588 to set symbol values (.equ, .equiv ). */
589static void
590s_nios2_set (int equiv)
591{
592 char *directive = input_line_pointer;
593 char delim = get_symbol_end ();
594 char *endline = input_line_pointer;
595 *endline = delim;
596
597 /* We only want to handle ".set XXX" if the
598 user has tried ".set XXX, YYY" they are not
599 trying a directive. This prevents
600 us from polluting the name space. */
601 SKIP_WHITESPACE ();
602 if (is_end_of_line[(unsigned char) *input_line_pointer])
603 {
604 bfd_boolean done = TRUE;
605 *endline = 0;
606
607 if (!strcmp (directive, "noat"))
608 nios2_as_options.noat = TRUE;
609 else if (!strcmp (directive, "at"))
610 nios2_as_options.noat = FALSE;
611 else if (!strcmp (directive, "nobreak"))
612 nios2_as_options.nobreak = TRUE;
613 else if (!strcmp (directive, "break"))
614 nios2_as_options.nobreak = FALSE;
615 else if (!strcmp (directive, "norelax"))
616 nios2_as_options.relax = relax_none;
617 else if (!strcmp (directive, "relaxsection"))
618 nios2_as_options.relax = relax_section;
619 else if (!strcmp (directive, "relaxall"))
620 nios2_as_options.relax = relax_all;
621 else
622 done = FALSE;
623
624 if (done)
625 {
626 *endline = delim;
627 demand_empty_rest_of_line ();
628 return;
629 }
630 }
631
632 /* If we fall through to here, either we have ".set XXX, YYY"
633 or we have ".set XXX" where XXX is unknown or we have
634 a syntax error. */
635 input_line_pointer = directive;
636 *endline = delim;
637 s_set (equiv);
638}
639
640/* Machine-dependent assembler directives.
641 Format of each entry is:
642 { "directive", handler_func, param } */
643const pseudo_typeS md_pseudo_table[] = {
644 {"align", s_nios2_align, 0},
645 {"text", s_nios2_text, 0},
646 {"data", s_nios2_data, 0},
647 {"section", s_nios2_section, 0},
648 {"section.s", s_nios2_section, 0},
649 {"sect", s_nios2_section, 0},
650 {"sect.s", s_nios2_section, 0},
651 /* .dword and .half are included for compatibility with MIPS. */
652 {"dword", cons, 8},
653 {"half", cons, 2},
654 /* NIOS2 native word size is 4 bytes, so we override
655 the GAS default of 2. */
656 {"word", cons, 4},
657 /* Explicitly unaligned directives. */
658 {"2byte", s_nios2_ucons, 2},
659 {"4byte", s_nios2_ucons, 4},
660 {"8byte", s_nios2_ucons, 8},
661 {"16byte", s_nios2_ucons, 16},
662#ifdef OBJ_ELF
663 {"sdata", s_nios2_sdata, 0},
664#endif
665 {"set", s_nios2_set, 0},
666 {NULL, NULL, 0}
667};
668
669\f
670/** Relaxation support. */
671
672/* We support two relaxation modes: a limited PC-relative mode with
673 -relax-section (the default), and an absolute jump mode with -relax-all.
674
675 Nios II PC-relative branch instructions only support 16-bit offsets.
676 And, there's no good way to add a 32-bit constant to the PC without
677 using two registers.
678
679 To deal with this, for the pc-relative relaxation mode we convert
680 br label
681 into a series of 16-bit adds, like:
682 nextpc at
683 addi at, at, 32767
684 ...
685 addi at, at, remainder
686 jmp at
687
688 Similarly, conditional branches are converted from
689 b(condition) r, s, label
690 into a series like:
691 b(opposite condition) r, s, skip
692 nextpc at
693 addi at, at, 32767
694 ...
695 addi at, at, remainder
696 jmp at
697 skip:
698
699 The compiler can do a better job, either by converting the branch
700 directly into a JMP (going through the GOT for PIC) or by allocating
701 a second register for the 32-bit displacement.
702
703 For the -relax-all relaxation mode, the conversions are
704 movhi at, %hi(symbol+offset)
705 ori at, %lo(symbol+offset)
706 jmp at
707 and
708 b(opposite condition), r, s, skip
709 movhi at, %hi(symbol+offset)
710 ori at, %lo(symbol+offset)
711 jmp at
712 skip:
713 respectively.
714*/
715
716/* Arbitrarily limit the number of addis we can insert; we need to be able
717 to specify the maximum growth size for each frag that contains a
718 relaxable branch. There's no point in specifying a huge number here
719 since that means the assembler needs to allocate that much extra
720 memory for every branch, and almost no real code will ever need it.
721 Plus, as already noted a better solution is to just use a jmp, or
722 allocate a second register to hold a 32-bit displacement.
723 FIXME: Rather than making this a constant, it could be controlled by
724 a command-line argument. */
725#define RELAX_MAX_ADDI 32
726
727/* The fr_subtype field represents the target-specific relocation state.
728 It has type relax_substateT (unsigned int). We use it to track the
729 number of addis necessary, plus a bit to track whether this is a
730 conditional branch.
731 Regardless of the smaller RELAX_MAX_ADDI limit, we reserve 16 bits
732 in the fr_subtype to encode the number of addis so that the whole
733 theoretically-valid range is representable.
734 For the -relax-all mode, N = 0 represents an in-range branch and N = 1
735 represents a branch that needs to be relaxed. */
736#define UBRANCH (0 << 16)
737#define CBRANCH (1 << 16)
738#define IS_CBRANCH(SUBTYPE) ((SUBTYPE) & CBRANCH)
739#define IS_UBRANCH(SUBTYPE) (!IS_CBRANCH (SUBTYPE))
740#define UBRANCH_SUBTYPE(N) (UBRANCH | (N))
741#define CBRANCH_SUBTYPE(N) (CBRANCH | (N))
742#define SUBTYPE_ADDIS(SUBTYPE) ((SUBTYPE) & 0xffff)
743
744/* For the -relax-section mode, unconditional branches require 2 extra i
745 nstructions besides the addis, conditional branches require 3. */
746#define UBRANCH_ADDIS_TO_SIZE(N) (((N) + 2) * 4)
747#define CBRANCH_ADDIS_TO_SIZE(N) (((N) + 3) * 4)
748
749/* For the -relax-all mode, unconditional branches require 3 instructions
750 and conditional branches require 4. */
751#define UBRANCH_JUMP_SIZE 12
752#define CBRANCH_JUMP_SIZE 16
753
754/* Maximum sizes of relaxation sequences. */
755#define UBRANCH_MAX_SIZE \
756 (nios2_as_options.relax == relax_all \
757 ? UBRANCH_JUMP_SIZE \
758 : UBRANCH_ADDIS_TO_SIZE (RELAX_MAX_ADDI))
759#define CBRANCH_MAX_SIZE \
760 (nios2_as_options.relax == relax_all \
761 ? CBRANCH_JUMP_SIZE \
762 : CBRANCH_ADDIS_TO_SIZE (RELAX_MAX_ADDI))
763
764/* Register number of AT, the assembler temporary. */
765#define AT_REGNUM 1
766
767/* Determine how many bytes are required to represent the sequence
768 indicated by SUBTYPE. */
769static int
770nios2_relax_subtype_size (relax_substateT subtype)
771{
772 int n = SUBTYPE_ADDIS (subtype);
773 if (n == 0)
774 /* Regular conditional/unconditional branch instruction. */
775 return 4;
776 else if (nios2_as_options.relax == relax_all)
777 return (IS_CBRANCH (subtype) ? CBRANCH_JUMP_SIZE : UBRANCH_JUMP_SIZE);
778 else if (IS_CBRANCH (subtype))
779 return CBRANCH_ADDIS_TO_SIZE (n);
780 else
781 return UBRANCH_ADDIS_TO_SIZE (n);
782}
783
784/* Estimate size of fragp before relaxation.
785 This could also examine the offset in fragp and adjust
786 fragp->fr_subtype, but we will do that in nios2_relax_frag anyway. */
787int
788md_estimate_size_before_relax (fragS *fragp, segT segment ATTRIBUTE_UNUSED)
789{
790 return nios2_relax_subtype_size (fragp->fr_subtype);
791}
792
793/* Implement md_relax_frag, returning the change in size of the frag. */
794long
795nios2_relax_frag (segT segment, fragS *fragp, long stretch)
796{
797 addressT target = fragp->fr_offset;
798 relax_substateT subtype = fragp->fr_subtype;
799 symbolS *symbolp = fragp->fr_symbol;
800
801 if (symbolp)
802 {
803 fragS *sym_frag = symbol_get_frag (symbolp);
804 offsetT offset;
805 int n;
806
807 target += S_GET_VALUE (symbolp);
808
809 /* See comments in write.c:relax_frag about handling of stretch. */
810 if (stretch != 0
811 && sym_frag->relax_marker != fragp->relax_marker)
812 {
813 if (stretch < 0 || sym_frag->region == fragp->region)
814 target += stretch;
815 else if (target < fragp->fr_address)
816 target = fragp->fr_next->fr_address + stretch;
817 }
818
819 /* We subtract 4 because all pc relative branches are
820 from the next instruction. */
821 offset = target - fragp->fr_address - fragp->fr_fix - 4;
822 if (offset >= -32768 && offset <= 32764)
823 /* Fits in PC-relative branch. */
824 n = 0;
825 else if (nios2_as_options.relax == relax_all)
826 /* Convert to jump. */
827 n = 1;
828 else if (nios2_as_options.relax == relax_section
829 && S_GET_SEGMENT (symbolp) == segment
830 && S_IS_DEFINED (symbolp))
831 /* Attempt a PC-relative relaxation on a branch to a defined
832 symbol in the same segment. */
833 {
834 /* The relaxation for conditional branches is offset by 4
835 bytes because we insert the inverted branch around the
836 sequence. */
837 if (IS_CBRANCH (subtype))
838 offset = offset - 4;
839 if (offset > 0)
840 n = offset / 32767 + 1;
841 else
842 n = offset / -32768 + 1;
843
844 /* Bail out immediately if relaxation has failed. If we try to
845 defer the diagnostic to md_convert_frag, some pathological test
846 cases (e.g. gcc/testsuite/gcc.c-torture/compile/20001226-1.c)
847 apparently never converge. By returning 0 here we could pretend
848 to the caller that nothing has changed, but that leaves things
849 in an inconsistent state when we get to md_convert_frag. */
850 if (n > RELAX_MAX_ADDI)
851 {
852 as_bad_where (fragp->fr_file, fragp->fr_line,
853 _("branch offset out of range\n"));
854 as_fatal (_("branch relaxation failed\n"));
855 }
856 }
857 else
858 /* We cannot handle this case, diagnose overflow later. */
859 return 0;
860
861 if (IS_CBRANCH (subtype))
862 fragp->fr_subtype = CBRANCH_SUBTYPE (n);
863 else
864 fragp->fr_subtype = UBRANCH_SUBTYPE (n);
865
866 return (nios2_relax_subtype_size (fragp->fr_subtype)
867 - nios2_relax_subtype_size (subtype));
868 }
869
870 /* If we got here, it's probably an error. */
871 return 0;
872}
873
874
875/* Complete fragp using the data from the relaxation pass. */
876void
877md_convert_frag (bfd *headers ATTRIBUTE_UNUSED, segT segment ATTRIBUTE_UNUSED,
878 fragS *fragp)
879{
880 char *buffer = fragp->fr_literal + fragp->fr_fix;
881 relax_substateT subtype = fragp->fr_subtype;
882 int n = SUBTYPE_ADDIS (subtype);
883 addressT target = fragp->fr_offset;
884 symbolS *symbolp = fragp->fr_symbol;
885 offsetT offset;
886 unsigned int addend_mask, addi_mask;
887 offsetT addend, remainder;
888 int i;
889
890 /* If we didn't or can't relax, this is a regular branch instruction.
891 We just need to generate the fixup for the symbol and offset. */
892 if (n == 0)
893 {
894 fix_new (fragp, fragp->fr_fix, 4, fragp->fr_symbol, fragp->fr_offset, 1,
895 BFD_RELOC_16_PCREL);
896 fragp->fr_fix += 4;
897 return;
898 }
899
900 /* Replace the cbranch at fr_fix with one that has the opposite condition
901 in order to jump around the block of instructions we'll be adding. */
902 if (IS_CBRANCH (subtype))
903 {
904 unsigned int br_opcode;
905 int nbytes;
906
907 /* Account for the nextpc and jmp in the pc-relative case, or the two
908 load instructions and jump in the absolute case. */
909 if (nios2_as_options.relax == relax_section)
910 nbytes = (n + 2) * 4;
911 else
912 nbytes = 12;
913
914 br_opcode = md_chars_to_number (buffer, 4);
915 switch (br_opcode & OP_MASK_OP)
916 {
917 case OP_MATCH_BEQ:
918 br_opcode = (br_opcode & ~OP_MASK_OP) | OP_MATCH_BNE;
919 break;
920 case OP_MATCH_BNE:
921 br_opcode = (br_opcode & ~OP_MASK_OP) | OP_MATCH_BEQ ;
922 break;
923 case OP_MATCH_BGE:
924 br_opcode = (br_opcode & ~OP_MASK_OP) | OP_MATCH_BLT ;
925 break;
926 case OP_MATCH_BGEU:
927 br_opcode = (br_opcode & ~OP_MASK_OP) | OP_MATCH_BLTU ;
928 break;
929 case OP_MATCH_BLT:
930 br_opcode = (br_opcode & ~OP_MASK_OP) | OP_MATCH_BGE ;
931 break;
932 case OP_MATCH_BLTU:
933 br_opcode = (br_opcode & ~OP_MASK_OP) | OP_MATCH_BGEU ;
934 break;
935 default:
936 as_bad_where (fragp->fr_file, fragp->fr_line,
937 _("expecting conditional branch for relaxation\n"));
938 abort ();
939 }
940
941 br_opcode = br_opcode | (nbytes << OP_SH_IMM16);
942 md_number_to_chars (buffer, br_opcode, 4);
943 fragp->fr_fix += 4;
944 buffer += 4;
945 }
946
947 /* Load at for the PC-relative case. */
948 if (nios2_as_options.relax == relax_section)
949 {
950 /* Insert the nextpc instruction. */
951 md_number_to_chars (buffer,
952 OP_MATCH_NEXTPC | (AT_REGNUM << OP_SH_RRD), 4);
953 fragp->fr_fix += 4;
954 buffer += 4;
955
956 /* We need to know whether the offset is positive or negative. */
957 target += S_GET_VALUE (symbolp);
958 offset = target - fragp->fr_address - fragp->fr_fix;
959 if (offset > 0)
960 addend = 32767;
961 else
962 addend = -32768;
963 addend_mask = (((unsigned int)addend) & 0xffff) << OP_SH_IMM16;
964
965 /* Insert n-1 addi instructions. */
966 addi_mask = (OP_MATCH_ADDI
967 | (AT_REGNUM << OP_SH_IRD)
968 | (AT_REGNUM << OP_SH_IRS));
969 for (i = 0; i < n - 1; i ++)
970 {
971 md_number_to_chars (buffer, addi_mask | addend_mask, 4);
972 fragp->fr_fix += 4;
973 buffer += 4;
974 }
975
976 /* Insert the last addi instruction to hold the remainder. */
977 remainder = offset - addend * (n - 1);
978 gas_assert (remainder >= -32768 && remainder <= 32767);
979 addend_mask = (((unsigned int)remainder) & 0xffff) << OP_SH_IMM16;
980 md_number_to_chars (buffer, addi_mask | addend_mask, 4);
981 fragp->fr_fix += 4;
982 buffer += 4;
983 }
984
985 /* Load at for the absolute case. */
986 else
987 {
988 md_number_to_chars (buffer, OP_MATCH_ORHI | 0x00400000, 4);
989 fix_new (fragp, fragp->fr_fix, 4, fragp->fr_symbol, fragp->fr_offset,
990 0, BFD_RELOC_NIOS2_HI16);
991 fragp->fr_fix += 4;
992 buffer += 4;
993 md_number_to_chars (buffer, OP_MATCH_ORI | 0x08400000, 4);
994 fix_new (fragp, fragp->fr_fix, 4, fragp->fr_symbol, fragp->fr_offset,
995 0, BFD_RELOC_NIOS2_LO16);
996 fragp->fr_fix += 4;
997 buffer += 4;
998 }
999
1000 /* Insert the jmp instruction. */
1001 md_number_to_chars (buffer, OP_MATCH_JMP | (AT_REGNUM << OP_SH_RRS), 4);
1002 fragp->fr_fix += 4;
1003 buffer += 4;
1004}
1005
1006\f
1007/** Fixups and overflow checking. */
1008
1009/* Check a fixup for overflow. */
1010static bfd_boolean
1011nios2_check_overflow (valueT fixup, reloc_howto_type *howto)
1012{
1013 /* Apply the rightshift before checking for overflow. */
1014 fixup = ((signed)fixup) >> howto->rightshift;
1015
1016 /* Check for overflow - return TRUE if overflow, FALSE if not. */
1017 switch (howto->complain_on_overflow)
1018 {
1019 case complain_overflow_dont:
1020 break;
1021 case complain_overflow_bitfield:
1022 if ((fixup >> howto->bitsize) != 0
1023 && ((signed) fixup >> howto->bitsize) != -1)
1024 return TRUE;
1025 break;
1026 case complain_overflow_signed:
1027 if ((fixup & 0x80000000) > 0)
1028 {
1029 /* Check for negative overflow. */
1030 if ((signed) fixup < ((signed) 0x80000000 >> howto->bitsize))
1031 return TRUE;
1032 }
1033 else
1034 {
1035 /* Check for positive overflow. */
1036 if (fixup >= ((unsigned) 1 << (howto->bitsize - 1)))
1037 return TRUE;
1038 }
1039 break;
1040 case complain_overflow_unsigned:
1041 if ((fixup >> howto->bitsize) != 0)
1042 return TRUE;
1043 break;
1044 default:
1045 as_bad (_("error checking for overflow - broken assembler"));
1046 break;
1047 }
1048 return FALSE;
1049}
1050
1051/* Emit diagnostic for fixup overflow. */
1052static void
1053nios2_diagnose_overflow (valueT fixup, reloc_howto_type *howto,
1054 fixS *fixP, valueT value)
1055{
1056 if (fixP->fx_r_type == BFD_RELOC_8
1057 || fixP->fx_r_type == BFD_RELOC_16
1058 || fixP->fx_r_type == BFD_RELOC_32)
1059 /* These relocs are against data, not instructions. */
1060 as_bad_where (fixP->fx_file, fixP->fx_line,
1061 _("immediate value 0x%x truncated to 0x%x"),
1062 (unsigned int) fixup,
1063 (unsigned int) (~(~(valueT) 0 << howto->bitsize) & fixup));
1064 else
1065 {
1066 /* What opcode is the instruction? This will determine
1067 whether we check for overflow in immediate values
1068 and what error message we get. */
1069 const struct nios2_opcode *opcode;
1070 enum overflow_type overflow_msg_type;
1071 unsigned int range_min;
1072 unsigned int range_max;
1073 unsigned int address;
1074 gas_assert (fixP->fx_size == 4);
1075 opcode = nios2_find_opcode_hash (value);
1076 gas_assert (opcode);
1077 overflow_msg_type = opcode->overflow_msg;
1078 switch (overflow_msg_type)
1079 {
1080 case call_target_overflow:
1081 range_min
1082 = ((fixP->fx_frag->fr_address + fixP->fx_where) & 0xf0000000);
1083 range_max = range_min + 0x0fffffff;
1084 address = fixup | range_min;
1085
1086 as_bad_where (fixP->fx_file, fixP->fx_line,
1087 _("call target address 0x%08x out of range 0x%08x to 0x%08x"),
1088 address, range_min, range_max);
1089 break;
1090 case branch_target_overflow:
1091 as_bad_where (fixP->fx_file, fixP->fx_line,
1092 _("branch offset %d out of range %d to %d"),
1093 (int)fixup, -32768, 32767);
1094 break;
1095 case address_offset_overflow:
1096 as_bad_where (fixP->fx_file, fixP->fx_line,
1097 _("%s offset %d out of range %d to %d"),
1098 opcode->name, (int)fixup, -32768, 32767);
1099 break;
1100 case signed_immed16_overflow:
1101 as_bad_where (fixP->fx_file, fixP->fx_line,
1102 _("immediate value %d out of range %d to %d"),
1103 (int)fixup, -32768, 32767);
1104 break;
1105 case unsigned_immed16_overflow:
1106 as_bad_where (fixP->fx_file, fixP->fx_line,
1107 _("immediate value %u out of range %u to %u"),
1108 (unsigned int)fixup, 0, 65535);
1109 break;
1110 case unsigned_immed5_overflow:
1111 as_bad_where (fixP->fx_file, fixP->fx_line,
1112 _("immediate value %u out of range %u to %u"),
1113 (unsigned int)fixup, 0, 31);
1114 break;
1115 case custom_opcode_overflow:
1116 as_bad_where (fixP->fx_file, fixP->fx_line,
1117 _("custom instruction opcode %u out of range %u to %u"),
1118 (unsigned int)fixup, 0, 255);
1119 break;
1120 default:
1121 as_bad_where (fixP->fx_file, fixP->fx_line,
1122 _("overflow in immediate argument"));
1123 break;
1124 }
1125 }
1126}
1127
1128/* Apply a fixup to the object file. */
1129void
1130md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
1131{
1132 /* Assert that the fixup is one we can handle. */
1133 gas_assert (fixP != NULL && valP != NULL
1134 && (fixP->fx_r_type == BFD_RELOC_8
1135 || fixP->fx_r_type == BFD_RELOC_16
1136 || fixP->fx_r_type == BFD_RELOC_32
1137 || fixP->fx_r_type == BFD_RELOC_64
1138 || fixP->fx_r_type == BFD_RELOC_NIOS2_S16
1139 || fixP->fx_r_type == BFD_RELOC_NIOS2_U16
1140 || fixP->fx_r_type == BFD_RELOC_16_PCREL
1141 || fixP->fx_r_type == BFD_RELOC_NIOS2_CALL26
1142 || fixP->fx_r_type == BFD_RELOC_NIOS2_IMM5
1143 || fixP->fx_r_type == BFD_RELOC_NIOS2_CACHE_OPX
1144 || fixP->fx_r_type == BFD_RELOC_NIOS2_IMM6
1145 || fixP->fx_r_type == BFD_RELOC_NIOS2_IMM8
1146 || fixP->fx_r_type == BFD_RELOC_NIOS2_HI16
1147 || fixP->fx_r_type == BFD_RELOC_NIOS2_LO16
1148 || fixP->fx_r_type == BFD_RELOC_NIOS2_HIADJ16
1149 || fixP->fx_r_type == BFD_RELOC_NIOS2_GPREL
1150 || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
1151 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY
1152 || fixP->fx_r_type == BFD_RELOC_NIOS2_UJMP
1153 || fixP->fx_r_type == BFD_RELOC_NIOS2_CJMP
1154 || fixP->fx_r_type == BFD_RELOC_NIOS2_CALLR
1155 || fixP->fx_r_type == BFD_RELOC_NIOS2_ALIGN
1156 || fixP->fx_r_type == BFD_RELOC_NIOS2_GOT16
1157 || fixP->fx_r_type == BFD_RELOC_NIOS2_CALL16
1158 || fixP->fx_r_type == BFD_RELOC_NIOS2_GOTOFF_LO
1159 || fixP->fx_r_type == BFD_RELOC_NIOS2_GOTOFF_HA
1160 || fixP->fx_r_type == BFD_RELOC_NIOS2_TLS_GD16
1161 || fixP->fx_r_type == BFD_RELOC_NIOS2_TLS_LDM16
1162 || fixP->fx_r_type == BFD_RELOC_NIOS2_TLS_LDO16
1163 || fixP->fx_r_type == BFD_RELOC_NIOS2_TLS_IE16
1164 || fixP->fx_r_type == BFD_RELOC_NIOS2_TLS_LE16
1165 || fixP->fx_r_type == BFD_RELOC_NIOS2_GOTOFF
1166 || fixP->fx_r_type == BFD_RELOC_NIOS2_TLS_DTPREL
1167 /* Add other relocs here as we generate them. */
1168 ));
1169
1170 if (fixP->fx_r_type == BFD_RELOC_64)
1171 {
1172 /* We may reach here due to .8byte directives, but we never output
1173 BFD_RELOC_64; it must be resolved. */
1174 if (fixP->fx_addsy != NULL)
1175 as_bad_where (fixP->fx_file, fixP->fx_line,
1176 _("cannot create 64-bit relocation"));
1177 else
1178 {
1179 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
1180 *valP, 8);
1181 fixP->fx_done = 1;
1182 }
1183 return;
1184 }
1185
1186 /* The value passed in valP can be the value of a fully
1187 resolved expression, or it can be the value of a partially
1188 resolved expression. In the former case, both fixP->fx_addsy
1189 and fixP->fx_subsy are NULL, and fixP->fx_offset == *valP, and
1190 we can fix up the instruction that fixP relates to.
1191 In the latter case, one or both of fixP->fx_addsy and
1192 fixP->fx_subsy are not NULL, and fixP->fx_offset may or may not
1193 equal *valP. We don't need to check for fixP->fx_subsy being null
1194 because the generic part of the assembler generates an error if
1195 it is not an absolute symbol. */
1196 if (fixP->fx_addsy != NULL)
1197 /* Partially resolved expression. */
1198 {
1199 fixP->fx_addnumber = fixP->fx_offset;
1200 fixP->fx_done = 0;
1201
1202 switch (fixP->fx_r_type)
1203 {
1204 case BFD_RELOC_NIOS2_TLS_GD16:
1205 case BFD_RELOC_NIOS2_TLS_LDM16:
1206 case BFD_RELOC_NIOS2_TLS_LDO16:
1207 case BFD_RELOC_NIOS2_TLS_IE16:
1208 case BFD_RELOC_NIOS2_TLS_LE16:
1209 case BFD_RELOC_NIOS2_TLS_DTPMOD:
1210 case BFD_RELOC_NIOS2_TLS_DTPREL:
1211 case BFD_RELOC_NIOS2_TLS_TPREL:
1212 S_SET_THREAD_LOCAL (fixP->fx_addsy);
1213 break;
1214 default:
1215 break;
1216 }
1217 }
1218 else
1219 /* Fully resolved fixup. */
1220 {
1221 reloc_howto_type *howto
1222 = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
1223
1224 if (howto == NULL)
1225 as_bad_where (fixP->fx_file, fixP->fx_line,
1226 _("relocation is not supported"));
1227 else
1228 {
1229 valueT fixup = *valP;
1230 valueT value;
1231 char *buf;
1232
1233 /* If this is a pc-relative relocation, we need to
1234 subtract the current offset within the object file
1235 FIXME : for some reason fixP->fx_pcrel isn't 1 when it should be
1236 so I'm using the howto structure instead to determine this. */
1237 if (howto->pc_relative == 1)
1238 fixup = fixup - (fixP->fx_frag->fr_address + fixP->fx_where + 4);
1239
1240 /* Get the instruction or data to be fixed up. */
1241 buf = fixP->fx_frag->fr_literal + fixP->fx_where;
1242 value = md_chars_to_number (buf, fixP->fx_size);
1243
1244 /* Check for overflow, emitting a diagnostic if necessary. */
1245 if (nios2_check_overflow (fixup, howto))
1246 nios2_diagnose_overflow (fixup, howto, fixP, value);
1247
1248 /* Apply the right shift. */
1249 fixup = ((signed)fixup) >> howto->rightshift;
1250
1251 /* Truncate the fixup to right size. */
1252 switch (fixP->fx_r_type)
1253 {
1254 case BFD_RELOC_NIOS2_HI16:
1255 fixup = (fixup >> 16) & 0xFFFF;
1256 break;
1257 case BFD_RELOC_NIOS2_LO16:
1258 fixup = fixup & 0xFFFF;
1259 break;
1260 case BFD_RELOC_NIOS2_HIADJ16:
5d5755a7
SL		 1261 fixup = ((((fixup >> 16) & 0xFFFF) + ((fixup >> 15) & 0x01))
1262 & 0xFFFF);
36591ba1
SL		 1263 break;
1264 default:
1265 {
1266 int n = sizeof (fixup) * 8 - howto->bitsize;
1267 fixup = (fixup << n) >> n;
1268 break;
1269 }
1270 }
1271
1272 /* Fix up the instruction. */
1273 value = (value & ~howto->dst_mask) | (fixup << howto->bitpos);
1274 md_number_to_chars (buf, value, fixP->fx_size);
1275 }
1276
1277 fixP->fx_done = 1;
1278 }
1279
1280 if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT)
1281 {
1282 fixP->fx_done = 0;
1283 if (fixP->fx_addsy
1284 && !S_IS_DEFINED (fixP->fx_addsy) && !S_IS_WEAK (fixP->fx_addsy))
1285 S_SET_WEAK (fixP->fx_addsy);
1286 }
1287 else if (fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
1288 fixP->fx_done = 0;
1289}
1290
1291
1292\f
1293/** Instruction parsing support. */
1294
1295/* Special relocation directive strings. */
1296
1297struct nios2_special_relocS
1298{
1299 const char *string;
1300 bfd_reloc_code_real_type reloc_type;
1301};
1302
1303struct nios2_special_relocS nios2_special_reloc[] = {
1304 {"%hiadj", BFD_RELOC_NIOS2_HIADJ16},
1305 {"%hi", BFD_RELOC_NIOS2_HI16},
1306 {"%lo", BFD_RELOC_NIOS2_LO16},
1307 {"%gprel", BFD_RELOC_NIOS2_GPREL},
1308 {"%call", BFD_RELOC_NIOS2_CALL16},
1309 {"%gotoff_lo", BFD_RELOC_NIOS2_GOTOFF_LO},
1310 {"%gotoff_hiadj", BFD_RELOC_NIOS2_GOTOFF_HA},
1311 {"%tls_gd", BFD_RELOC_NIOS2_TLS_GD16},
1312 {"%tls_ldm", BFD_RELOC_NIOS2_TLS_LDM16},
1313 {"%tls_ldo", BFD_RELOC_NIOS2_TLS_LDO16},
1314 {"%tls_ie", BFD_RELOC_NIOS2_TLS_IE16},
1315 {"%tls_le", BFD_RELOC_NIOS2_TLS_LE16},
1316 {"%gotoff", BFD_RELOC_NIOS2_GOTOFF},
1317 {"%got", BFD_RELOC_NIOS2_GOT16}
1318};
1319
1320#define NIOS2_NUM_SPECIAL_RELOCS \
1321 (sizeof(nios2_special_reloc)/sizeof(nios2_special_reloc[0]))
1322const int nios2_num_special_relocs = NIOS2_NUM_SPECIAL_RELOCS;
1323
1324/* Creates a new nios2_insn_relocS and returns a pointer to it. */
1325static nios2_insn_relocS *
1326nios2_insn_reloc_new (bfd_reloc_code_real_type reloc_type, unsigned int pcrel)
1327{
1328 nios2_insn_relocS *retval;
1329 retval = (nios2_insn_relocS *) malloc (sizeof (nios2_insn_relocS));
1330 if (retval == NULL)
1331 {
1332 as_bad (_("can't create relocation"));
1333 abort ();
1334 }
1335
1336 /* Fill out the fields with default values. */
1337 retval->reloc_next = NULL;
1338 retval->reloc_type = reloc_type;
1339 retval->reloc_pcrel = pcrel;
1340 return retval;
1341}
1342
1343/* Frees up memory previously allocated by nios2_insn_reloc_new(). */
1344/* FIXME: this is never called; memory leak? */
1345#if 0
1346static void
1347nios2_insn_reloc_destroy (nios2_insn_relocS *reloc)
1348{
1349 gas_assert (reloc != NULL);
1350 free (reloc);
1351}
1352#endif
1353
1354/* The various nios2_assemble_* functions call this
1355 function to generate an expression from a string representing an expression.
1356 It then tries to evaluate the expression, and if it can, returns its value.
1357 If not, it creates a new nios2_insn_relocS and stores the expression and
1358 reloc_type for future use. */
1359static unsigned long
1360nios2_assemble_expression (const char *exprstr,
1361 nios2_insn_infoS *insn,
1362 nios2_insn_relocS *prev_reloc,
1363 bfd_reloc_code_real_type reloc_type,
1364 unsigned int pcrel)
1365{
1366 nios2_insn_relocS *reloc;
1367 char *saved_line_ptr;
1368 unsigned short value;
1369 int i;
1370
1371 gas_assert (exprstr != NULL);
1372 gas_assert (insn != NULL);
1373
1374 /* Check for relocation operators.
1375 Change the relocation type and advance the ptr to the start of
1376 the expression proper. */
1377 for (i = 0; i < nios2_num_special_relocs; i++)
1378 if (strstr (exprstr, nios2_special_reloc[i].string) != NULL)
1379 {
1380 reloc_type = nios2_special_reloc[i].reloc_type;
1381 exprstr += strlen (nios2_special_reloc[i].string) + 1;
1382
1383 /* %lo and %hiadj have different meanings for PC-relative
1384 expressions. */
1385 if (pcrel)
1386 {
1387 if (reloc_type == BFD_RELOC_NIOS2_LO16)
1388 reloc_type = BFD_RELOC_NIOS2_PCREL_LO;
1389 if (reloc_type == BFD_RELOC_NIOS2_HIADJ16)
1390 reloc_type = BFD_RELOC_NIOS2_PCREL_HA;
1391 }
1392
1393 break;
1394 }
1395
1396 /* We potentially have a relocation. */
1397 reloc = nios2_insn_reloc_new (reloc_type, pcrel);
1398 if (prev_reloc != NULL)
1399 prev_reloc->reloc_next = reloc;
1400 else
1401 insn->insn_reloc = reloc;
1402
1403 /* Parse the expression string. */
1404 saved_line_ptr = input_line_pointer;
1405 input_line_pointer = (char *) exprstr;
1406 expression (&reloc->reloc_expression);
1407 input_line_pointer = saved_line_ptr;
1408
1409 /* This is redundant as the fixup will put this into
1410 the instruction, but it is included here so that
1411 self-test mode (-r) works. */
1412 value = 0;
1413 if (nios2_mode == NIOS2_MODE_TEST
1414 && reloc->reloc_expression.X_op == O_constant)
1415 value = reloc->reloc_expression.X_add_number;
1416
1417 return (unsigned long) value;
1418}
1419
1420/* Argument assemble functions.
1421 All take an instruction argument string, and a pointer
1422 to an instruction opcode. Upon return the insn_opcode
1423 has the relevant fields filled in to represent the arg
1424 string. The return value is NULL if successful, or
1425 an error message if an error was detected.
1426
1427 The naming conventions for these functions match the args template
1428 in the nios2_opcode structure, as documented in include/opcode/nios2.h.
1429 For example, nios2_assemble_args_dst is used for instructions with
1430 "d,s,t" args.
1431 See nios2_arg_info_structs below for the exact correspondence. */
1432
1433static void
1434nios2_assemble_args_dst (nios2_insn_infoS *insn_info)
1435{
1436 if (insn_info->insn_tokens[1] != NULL
1437 && insn_info->insn_tokens[2] != NULL
1438 && insn_info->insn_tokens[3] != NULL)
1439 {
1440 struct nios2_reg *dst = nios2_reg_lookup (insn_info->insn_tokens[1]);
1441 struct nios2_reg *src1 = nios2_reg_lookup (insn_info->insn_tokens[2]);
1442 struct nios2_reg *src2 = nios2_reg_lookup (insn_info->insn_tokens[3]);
1443
1444 if (dst == NULL)
1445 as_bad (_("unknown register %s"), insn_info->insn_tokens[1]);
1446 else
1447 SET_INSN_FIELD (RRD, insn_info->insn_code, dst->index);
1448
1449 if (src1 == NULL)
1450 as_bad (_("unknown register %s"), insn_info->insn_tokens[2]);
1451 else
1452 SET_INSN_FIELD (RRS, insn_info->insn_code, src1->index);
1453
1454 if (src2 == NULL)
1455 as_bad (_("unknown register %s"), insn_info->insn_tokens[3]);
1456 else
1457 SET_INSN_FIELD (RRT, insn_info->insn_code, src2->index);
1458
1459 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[4]);
1460 }
1461}
1462
1463static void
1464nios2_assemble_args_tsi (nios2_insn_infoS *insn_info)
1465{
1466 if (insn_info->insn_tokens[1] != NULL &&
1467 insn_info->insn_tokens[2] != NULL && insn_info->insn_tokens[3] != NULL)
1468 {
1469 struct nios2_reg *dst = nios2_reg_lookup (insn_info->insn_tokens[1]);
1470 struct nios2_reg *src1 = nios2_reg_lookup (insn_info->insn_tokens[2]);
1471 unsigned int src2
1472 = nios2_assemble_expression (insn_info->insn_tokens[3], insn_info,
1473 insn_info->insn_reloc, BFD_RELOC_NIOS2_S16,
1474 0);
1475
1476 if (dst == NULL)
1477 as_bad (_("unknown register %s"), insn_info->insn_tokens[1]);
1478 else
1479 SET_INSN_FIELD (IRT, insn_info->insn_code, dst->index);
1480
1481 if (src1 == NULL)
1482 as_bad (_("unknown register %s"), insn_info->insn_tokens[2]);
1483 else
1484 SET_INSN_FIELD (IRS, insn_info->insn_code, src1->index);
1485
1486 SET_INSN_FIELD (IMM16, insn_info->insn_code, src2);
1487 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[4]);
1488 SET_INSN_FIELD (IMM16, insn_info->insn_code, 0);
1489 }
1490}
1491
1492static void
1493nios2_assemble_args_tsu (nios2_insn_infoS *insn_info)
1494{
1495 if (insn_info->insn_tokens[1] != NULL
1496 && insn_info->insn_tokens[2] != NULL
1497 && insn_info->insn_tokens[3] != NULL)
1498 {
1499 struct nios2_reg *dst = nios2_reg_lookup (insn_info->insn_tokens[1]);
1500 struct nios2_reg *src1 = nios2_reg_lookup (insn_info->insn_tokens[2]);
1501 unsigned int src2
1502 = nios2_assemble_expression (insn_info->insn_tokens[3], insn_info,
1503 insn_info->insn_reloc, BFD_RELOC_NIOS2_U16,
1504 0);
1505
1506 if (dst == NULL)
1507 as_bad (_("unknown register %s"), insn_info->insn_tokens[1]);
1508 else
1509 SET_INSN_FIELD (IRT, insn_info->insn_code, dst->index);
1510
1511 if (src1 == NULL)
1512 as_bad (_("unknown register %s"), insn_info->insn_tokens[2]);
1513 else
1514 SET_INSN_FIELD (IRS, insn_info->insn_code, src1->index);
1515
1516 SET_INSN_FIELD (IMM16, insn_info->insn_code, src2);
1517 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[4]);
1518 SET_INSN_FIELD (IMM16, insn_info->insn_code, 0);
1519 }
1520}
1521
1522static void
1523nios2_assemble_args_sto (nios2_insn_infoS *insn_info)
1524{
1525 if (insn_info->insn_tokens[1] != NULL
1526 && insn_info->insn_tokens[2] != NULL
1527 && insn_info->insn_tokens[3] != NULL)
1528 {
1529 struct nios2_reg *dst = nios2_reg_lookup (insn_info->insn_tokens[1]);
1530 struct nios2_reg *src1 = nios2_reg_lookup (insn_info->insn_tokens[2]);
1531 unsigned int src2
1532 = nios2_assemble_expression (insn_info->insn_tokens[3], insn_info,
1533 insn_info->insn_reloc, BFD_RELOC_16_PCREL,
1534 1);
1535
1536 if (dst == NULL)
1537 as_bad (_("unknown register %s"), insn_info->insn_tokens[1]);
1538 else
1539 SET_INSN_FIELD (IRS, insn_info->insn_code, dst->index);
1540
1541 if (src1 == NULL)
1542 as_bad (_("unknown register %s"), insn_info->insn_tokens[2]);
1543 else
1544 SET_INSN_FIELD (IRT, insn_info->insn_code, src1->index);
1545
1546 SET_INSN_FIELD (IMM16, insn_info->insn_code, src2);
1547 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[4]);
1548 SET_INSN_FIELD (IMM16, insn_info->insn_code, 0);
1549 }
1550}
1551
1552static void
1553nios2_assemble_args_o (nios2_insn_infoS *insn_info)
1554{
1555 if (insn_info->insn_tokens[1] != NULL)
1556 {
1557 unsigned long immed
1558 = nios2_assemble_expression (insn_info->insn_tokens[1], insn_info,
1559 insn_info->insn_reloc, BFD_RELOC_16_PCREL,
1560 1);
1561 SET_INSN_FIELD (IMM16, insn_info->insn_code, immed);
1562 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[2]);
1563 SET_INSN_FIELD (IMM16, insn_info->insn_code, 0);
1564 }
1565}
1566
1567static void
1568nios2_assemble_args_is (nios2_insn_infoS *insn_info)
1569{
1570 if (insn_info->insn_tokens[1] != NULL && insn_info->insn_tokens[2] != NULL)
1571 {
1572 struct nios2_reg *addr_src = nios2_reg_lookup (insn_info->insn_tokens[2]);
1573 unsigned long immed
1574 = nios2_assemble_expression (insn_info->insn_tokens[1], insn_info,
1575 insn_info->insn_reloc, BFD_RELOC_NIOS2_S16,
1576 0);
1577
1578 SET_INSN_FIELD (IMM16, insn_info->insn_code, immed);
1579
1580 if (addr_src == NULL)
1581 as_bad (_("unknown base register %s"), insn_info->insn_tokens[2]);
1582 else
1583 SET_INSN_FIELD (RRS, insn_info->insn_code, addr_src->index);
1584
1585 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[3]);
1586 SET_INSN_FIELD (IMM16, insn_info->insn_code, 0);
1587 }
1588}
1589
1590static void
1591nios2_assemble_args_m (nios2_insn_infoS *insn_info)
1592{
1593 if (insn_info->insn_tokens[1] != NULL)
1594 {
1595 unsigned long immed
1596 = nios2_assemble_expression (insn_info->insn_tokens[1], insn_info,
1597 insn_info->insn_reloc,
1598 BFD_RELOC_NIOS2_CALL26, 0);
1599
1600 SET_INSN_FIELD (IMM26, insn_info->insn_code, immed);
1601 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[2]);
1602 SET_INSN_FIELD (IMM26, insn_info->insn_code, 0);
1603 }
1604}
1605
1606static void
1607nios2_assemble_args_s (nios2_insn_infoS *insn_info)
1608{
1609 if (insn_info->insn_tokens[1] != NULL)
1610 {
1611 struct nios2_reg *src = nios2_reg_lookup (insn_info->insn_tokens[1]);
1612 if (src == NULL)
1613 as_bad (_("unknown register %s"), insn_info->insn_tokens[1]);
1614 else
1615 SET_INSN_FIELD (RRS, insn_info->insn_code, src->index);
1616
1617 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[2]);
1618 }
1619}
1620
1621static void
1622nios2_assemble_args_tis (nios2_insn_infoS *insn_info)
1623{
1624 if (insn_info->insn_tokens[1] != NULL
1625 && insn_info->insn_tokens[2] != NULL
1626 && insn_info->insn_tokens[3] != NULL)
1627 {
1628 struct nios2_reg *dst = nios2_reg_lookup (insn_info->insn_tokens[1]);
1629 struct nios2_reg *addr_src = nios2_reg_lookup (insn_info->insn_tokens[3]);
1630 unsigned long immed
1631 = nios2_assemble_expression (insn_info->insn_tokens[2], insn_info,
1632 insn_info->insn_reloc, BFD_RELOC_NIOS2_S16,
1633 0);
1634
1635 if (addr_src == NULL)
1636 as_bad (_("unknown register %s"), insn_info->insn_tokens[3]);
1637 else
1638 SET_INSN_FIELD (RRS, insn_info->insn_code, addr_src->index);
1639
1640 if (dst == NULL)
1641 as_bad (_("unknown register %s"), insn_info->insn_tokens[1]);
1642 else
1643 SET_INSN_FIELD (RRT, insn_info->insn_code, dst->index);
1644
1645 SET_INSN_FIELD (IMM16, insn_info->insn_code, immed);
1646 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[4]);
1647 SET_INSN_FIELD (IMM16, insn_info->insn_code, 0);
1648 }
1649}
1650
1651static void
1652nios2_assemble_args_dc (nios2_insn_infoS *insn_info)
1653{
1654 if (insn_info->insn_tokens[1] != NULL && insn_info->insn_tokens[2] != NULL)
1655 {
1656 struct nios2_reg *ctl = nios2_reg_lookup (insn_info->insn_tokens[2]);
1657 struct nios2_reg *dst = nios2_reg_lookup (insn_info->insn_tokens[1]);
1658
1659 if (ctl == NULL)
1660 as_bad (_("unknown register %s"), insn_info->insn_tokens[1]);
1661 else
1662 SET_INSN_FIELD (RCTL, insn_info->insn_code, ctl->index);
1663
1664 if (dst == NULL)
1665 as_bad (_("unknown register %s"), insn_info->insn_tokens[2]);
1666 else
1667 SET_INSN_FIELD (RRD, insn_info->insn_code, dst->index);
1668
1669 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[3]);
1670 }
1671}
1672
1673static void
1674nios2_assemble_args_cs (nios2_insn_infoS *insn_info)
1675{
1676 if (insn_info->insn_tokens[1] != NULL && insn_info->insn_tokens[2] != NULL)
1677 {
1678 struct nios2_reg *ctl = nios2_reg_lookup (insn_info->insn_tokens[1]);
1679 struct nios2_reg *src = nios2_reg_lookup (insn_info->insn_tokens[2]);
1680
1681 if (ctl == NULL)
1682 as_bad (_("unknown register %s"), insn_info->insn_tokens[1]);
1683 else if (ctl->index == 4)
1684 as_bad (_("ipending control register (ctl4) is read-only\n"));
1685 else
1686 SET_INSN_FIELD (RCTL, insn_info->insn_code, ctl->index);
1687
1688 if (src == NULL)
1689 as_bad (_("unknown register %s"), insn_info->insn_tokens[2]);
1690 else
1691 SET_INSN_FIELD (RRS, insn_info->insn_code, src->index);
1692
1693 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[3]);
1694 }
1695}
1696
dad60f8e
SL		 1697static void
1698nios2_assemble_args_ds (nios2_insn_infoS * insn_info)
1699{
1700 if (insn_info->insn_tokens[1] != NULL && insn_info->insn_tokens[2] != NULL)
1701 {
1702 struct nios2_reg *dst = nios2_reg_lookup (insn_info->insn_tokens[1]);
1703 struct nios2_reg *src = nios2_reg_lookup (insn_info->insn_tokens[2]);
1704
1705 if (dst == NULL)
1706 as_bad (_("unknown register %s"), insn_info->insn_tokens[1]);
1707 else
1708 SET_INSN_FIELD (RRD, insn_info->insn_code, dst->index);
1709
1710 if (src == NULL)
1711 as_bad (_("unknown register %s"), insn_info->insn_tokens[2]);
1712 else
1713 SET_INSN_FIELD (RRS, insn_info->insn_code, src->index);
1714
1715 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[3]);
1716 }
1717}
1718
36591ba1
SL		 1719static void
1720nios2_assemble_args_ldst (nios2_insn_infoS *insn_info)
1721{
1722 if (insn_info->insn_tokens[1] != NULL
1723 && insn_info->insn_tokens[2] != NULL
1724 && insn_info->insn_tokens[3] != NULL
1725 && insn_info->insn_tokens[4] != NULL)
1726 {
1727 unsigned long custom_n
1728 = nios2_assemble_expression (insn_info->insn_tokens[1], insn_info,
1729 insn_info->insn_reloc,
1730 BFD_RELOC_NIOS2_IMM8, 0);
1731
1732 struct nios2_reg *dst = nios2_reg_lookup (insn_info->insn_tokens[2]);
1733 struct nios2_reg *src1 = nios2_reg_lookup (insn_info->insn_tokens[3]);
1734 struct nios2_reg *src2 = nios2_reg_lookup (insn_info->insn_tokens[4]);
1735
1736 SET_INSN_FIELD (CUSTOM_N, insn_info->insn_code, custom_n);
1737
1738 if (dst == NULL)
1739 as_bad (_("unknown register %s"), insn_info->insn_tokens[2]);
1740 else
1741 SET_INSN_FIELD (RRD, insn_info->insn_code, dst->index);
1742
1743 if (src1 == NULL)
1744 as_bad (_("unknown register %s"), insn_info->insn_tokens[3]);
1745 else
1746 SET_INSN_FIELD (RRS, insn_info->insn_code, src1->index);
1747
1748 if (src2 == NULL)
1749 as_bad (_("unknown register %s"), insn_info->insn_tokens[4]);
1750 else
1751 SET_INSN_FIELD (RRT, insn_info->insn_code, src2->index);
1752
1753 /* Set or clear the bits to indicate whether coprocessor registers are
1754 used. */
1755 if (nios2_coproc_reg (insn_info->insn_tokens[2]))
1756 SET_INSN_FIELD (CUSTOM_C, insn_info->insn_code, 0);
1757 else
1758 SET_INSN_FIELD (CUSTOM_C, insn_info->insn_code, 1);
1759
1760 if (nios2_coproc_reg (insn_info->insn_tokens[3]))
1761 SET_INSN_FIELD (CUSTOM_A, insn_info->insn_code, 0);
1762 else
1763 SET_INSN_FIELD (CUSTOM_A, insn_info->insn_code, 1);
1764
1765 if (nios2_coproc_reg (insn_info->insn_tokens[4]))
1766 SET_INSN_FIELD (CUSTOM_B, insn_info->insn_code, 0);
1767 else
1768 SET_INSN_FIELD (CUSTOM_B, insn_info->insn_code, 1);
1769
1770 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[5]);
1771 }
1772}
1773
1774static void
1775nios2_assemble_args_none (nios2_insn_infoS *insn_info ATTRIBUTE_UNUSED)
1776{
1777 /* Nothing to do. */
1778}
1779
1780static void
1781nios2_assemble_args_dsj (nios2_insn_infoS *insn_info)
1782{
1783 if (insn_info->insn_tokens[1] != NULL
1784 && insn_info->insn_tokens[2] != NULL
1785 && insn_info->insn_tokens[3] != NULL)
1786 {
1787 struct nios2_reg *dst = nios2_reg_lookup (insn_info->insn_tokens[1]);
1788 struct nios2_reg *src1 = nios2_reg_lookup (insn_info->insn_tokens[2]);
1789
1790 /* A 5-bit constant expression. */
1791 unsigned int src2 =
1792 nios2_assemble_expression (insn_info->insn_tokens[3], insn_info,
1793 insn_info->insn_reloc,
1794 BFD_RELOC_NIOS2_IMM5, 0);
1795
1796 if (dst == NULL)
1797 as_bad (_("unknown register %s"), insn_info->insn_tokens[1]);
1798 else
1799 SET_INSN_FIELD (RRD, insn_info->insn_code, dst->index);
1800
1801 if (src1 == NULL)
1802 as_bad (_("unknown register %s"), insn_info->insn_tokens[2]);
1803 else
1804 SET_INSN_FIELD (RRS, insn_info->insn_code, src1->index);
1805
1806 SET_INSN_FIELD (IMM5, insn_info->insn_code, src2);
1807 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[4]);
1808 SET_INSN_FIELD (IMM5, insn_info->insn_code, 0);
1809 }
1810}
1811
1812static void
1813nios2_assemble_args_d (nios2_insn_infoS *insn_info)
1814{
1815 if (insn_info->insn_tokens[1] != NULL)
1816 {
1817 struct nios2_reg *dst = nios2_reg_lookup (insn_info->insn_tokens[1]);
1818
1819 if (dst == NULL)
1820 as_bad (_("unknown register %s"), insn_info->insn_tokens[1]);
1821 else
1822 SET_INSN_FIELD (RRD, insn_info->insn_code, dst->index);
1823
1824 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[2]);
1825 }
1826}
1827
1828static void
1829nios2_assemble_args_b (nios2_insn_infoS *insn_info)
1830{
1831 unsigned int imm5 = 0;
1832
1833 if (insn_info->insn_tokens[1] != NULL)
1834 {
1835 /* A 5-bit constant expression. */
1836 imm5 = nios2_assemble_expression (insn_info->insn_tokens[1],
1837 insn_info, insn_info->insn_reloc,
1838 BFD_RELOC_NIOS2_IMM5, 0);
1839 SET_INSN_FIELD (TRAP_IMM5, insn_info->insn_code, imm5);
1840 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[2]);
1841 }
1842
1843 SET_INSN_FIELD (TRAP_IMM5, insn_info->insn_code, imm5);
1844
1845 nios2_check_assembly (insn_info->insn_code, insn_info->insn_tokens[2]);
1846}
1847
1848/* This table associates pointers to functions that parse the arguments to an
1849 instruction and fill in the relevant fields of the instruction. */
1850const nios2_arg_infoS nios2_arg_info_structs[] = {
1851 /* args, assemble_args_func */
1852 {"d,s,t", nios2_assemble_args_dst},
1853 {"d,s,t,E", nios2_assemble_args_dst},
1854 {"t,s,i", nios2_assemble_args_tsi},
1855 {"t,s,i,E", nios2_assemble_args_tsi},
1856 {"t,s,u", nios2_assemble_args_tsu},
1857 {"t,s,u,E", nios2_assemble_args_tsu},
1858 {"s,t,o", nios2_assemble_args_sto},
1859 {"s,t,o,E", nios2_assemble_args_sto},
1860 {"o", nios2_assemble_args_o},
1861 {"o,E", nios2_assemble_args_o},
1862 {"s", nios2_assemble_args_s},
1863 {"s,E", nios2_assemble_args_s},
1864 {"", nios2_assemble_args_none},
1865 {"E", nios2_assemble_args_none},
1866 {"i(s)", nios2_assemble_args_is},
1867 {"i(s)E", nios2_assemble_args_is},
1868 {"m", nios2_assemble_args_m},
1869 {"m,E", nios2_assemble_args_m},
1870 {"t,i(s)", nios2_assemble_args_tis},
1871 {"t,i(s)E", nios2_assemble_args_tis},
1872 {"d,c", nios2_assemble_args_dc},
1873 {"d,c,E", nios2_assemble_args_dc},
1874 {"c,s", nios2_assemble_args_cs},
1875 {"c,s,E", nios2_assemble_args_cs},
dad60f8e
SL		 1876 {"d,s", nios2_assemble_args_ds},
1877 {"d,s,E", nios2_assemble_args_ds},
36591ba1
SL		 1878 {"l,d,s,t", nios2_assemble_args_ldst},
1879 {"l,d,s,t,E", nios2_assemble_args_ldst},
1880 {"d,s,j", nios2_assemble_args_dsj},
1881 {"d,s,j,E", nios2_assemble_args_dsj},
1882 {"d", nios2_assemble_args_d},
1883 {"d,E", nios2_assemble_args_d},
1884 {"b", nios2_assemble_args_b},
1885 {"b,E", nios2_assemble_args_b}
1886};
1887
1888#define NIOS2_NUM_ARGS \
1889 ((sizeof(nios2_arg_info_structs)/sizeof(nios2_arg_info_structs[0])))
1890const int nios2_num_arg_info_structs = NIOS2_NUM_ARGS;
1891
1892/* The function consume_arg takes a pointer into a string
1893 of instruction tokens (args) and a pointer into a string
1894 representing the expected sequence of tokens and separators.
1895 It checks whether the first argument in argstr is of the
1896 expected type, throwing an error if it is not, and returns
1897 the pointer argstr. */
1898static char *
1899nios2_consume_arg (nios2_insn_infoS *insn, char *argstr, const char *parsestr)
1900{
1901 char *temp;
1902 int regno = -1;
1903
1904 switch (*parsestr)
1905 {
1906 case 'c':
1907 if (!nios2_control_register_arg_p (argstr))
1908 as_bad (_("expecting control register"));
1909 break;
1910 case 'd':
1911 case 's':
1912 case 't':
1913
1914 /* We check to make sure we don't have a control register. */
1915 if (nios2_control_register_arg_p (argstr))
1916 as_bad (_("illegal use of control register"));
1917
1918 /* And whether coprocessor registers are valid here. */
1919 if (nios2_coproc_reg (argstr)
1920 && insn->insn_nios2_opcode->match != OP_MATCH_CUSTOM)
1921 as_bad (_("illegal use of coprocessor register\n"));
1922
1923 /* Extract a register number if the register is of the
1924 form r[0-9]+, if it is a normal register, set
1925 regno to its number (0-31), else set regno to -1. */
1926 if (argstr[0] == 'r' && ISDIGIT (argstr[1]))
1927 {
1928 char *p = argstr;
1929
1930 ++p;
1931 regno = 0;
1932 do
1933 {
1934 regno *= 10;
1935 regno += *p - '0';
1936 ++p;
1937 }
1938 while (ISDIGIT (*p));
1939 }
1940 else
1941 regno = -1;
1942
1943 /* And whether we are using at. */
1944 if (!nios2_as_options.noat
1945 && (regno == 1 || strprefix (argstr, "at")))
1946 as_warn (_("Register at (r1) can sometimes be corrupted by assembler "
1947 "optimizations.\n"
1948 "Use .set noat to turn off those optimizations (and this "
1949 "warning)."));
1950
1951 /* And whether we are using oci registers. */
1952 if (!nios2_as_options.nobreak
1953 && (regno == 25 || strprefix (argstr, "bt")))
1954 as_warn (_("The debugger will corrupt bt (r25). If you don't need to "
1955 "debug this\n"
1956 "code then use .set nobreak to turn off this warning."));
1957
1958 if (!nios2_as_options.nobreak
1959 && (regno == 30 || strprefix (argstr, "ba")))
1960 as_warn (_("The debugger will corrupt ba (r30). If you don't need to "
1961 "debug this\n"
1962 "code then use .set nobreak to turn off this warning."));
1963 break;
1964 case 'i':
1965 case 'u':
1966 if (*argstr == '%')
1967 {
1968 if (nios2_special_relocation_p (argstr))
1969 {
1970 /* We zap the parentheses because we don't want them confused
1971 with separators. */
1972 temp = strchr (argstr, '(');
1973 if (temp != NULL)
1974 *temp = ' ';
1975 temp = strchr (argstr, ')');
1976 if (temp != NULL)
1977 *temp = ' ';
1978 }
1979 else
1980 as_bad (_("badly formed expression near %s"), argstr);
1981 }
1982 break;
1983 case 'm':
1984 case 'j':
36591ba1
SL		 1985 case 'l':
1986 case 'b':
1987 /* We can't have %hi, %lo or %hiadj here. */
1988 if (*argstr == '%')
1989 as_bad (_("badly formed expression near %s"), argstr);
1990 break;
531a94fd
SL		 1991 case 'o':
1992 break;
36591ba1 1993 default:
531a94fd 1994 BAD_CASE (*parsestr);
36591ba1
SL		 1995 break;
1996 }
1997
1998 return argstr;
1999}
2000
2001/* The function consume_separator takes a pointer into a string
2002 of instruction tokens (args) and a pointer into a string representing
2003 the expected sequence of tokens and separators. It finds the first
2004 instance of the character pointed to by separator in argstr, and
2005 returns a pointer to the next element of argstr, which is the
2006 following token in the sequence. */
2007static char *
2008nios2_consume_separator (char *argstr, const char *separator)
2009{
2010 char *p;
2011
2012 /* If we have a opcode reg, expr(reg) type instruction, and
2013 * we are separating the expr from the (reg), we find the last
2014 * (, just in case the expression has parentheses. */
2015
2016 if (*separator == '(')
2017 p = strrchr (argstr, *separator);
2018 else
2019 p = strchr (argstr, *separator);
2020
2021 if (p != NULL)
2022 *p++ = 0;
2023 else
2024 as_bad (_("expecting %c near %s"), *separator, argstr);
2025 return p;
2026}
2027
2028
2029/* The principal argument parsing function which takes a string argstr
2030 representing the instruction arguments for insn, and extracts the argument
2031 tokens matching parsestr into parsed_args. */
2032static void
2033nios2_parse_args (nios2_insn_infoS *insn, char *argstr,
2034 const char *parsestr, char **parsed_args)
2035{
2036 char *p;
2037 char *end = NULL;
2038 int i;
2039 p = argstr;
2040 i = 0;
2041 bfd_boolean terminate = FALSE;
2042
2043 /* This rest of this function is it too fragile and it mostly works,
2044 therefore special case this one. */
2045 if (*parsestr == 0 && argstr != 0)
2046 {
2047 as_bad (_("too many arguments"));
2048 parsed_args[0] = NULL;
2049 return;
2050 }
2051
2052 while (p != NULL && !terminate && i < NIOS2_MAX_INSN_TOKENS)
2053 {
2054 parsed_args[i] = nios2_consume_arg (insn, p, parsestr);
2055 ++parsestr;
2056 if (*parsestr != '\0')
2057 {
2058 p = nios2_consume_separator (p, parsestr);
2059 ++parsestr;
2060 }
2061 else
2062 {
2063 /* Check that the argument string has no trailing arguments. */
2064 /* If we've got a %lo etc relocation, we've zapped the parens with
2065 spaces. */
2066 if (nios2_special_relocation_p (p))
2067 end = strpbrk (p, ",");
2068 else
2069 end = strpbrk (p, " ,");
2070
2071 if (end != NULL)
2072 as_bad (_("too many arguments"));
2073 }
2074
2075 if (*parsestr == '\0' || (p != NULL && *p == '\0'))
2076 terminate = TRUE;
2077 ++i;
2078 }
2079
2080 parsed_args[i] = NULL;
2081
9daf7bab
SL		 2082 /* The argument to break and trap instructions is optional; complain
2083 for other cases of missing arguments. */
2084 if (*parsestr != '\0'
2085 && insn->insn_nios2_opcode->match != OP_MATCH_BREAK
2086 && insn->insn_nios2_opcode->match != OP_MATCH_TRAP)
36591ba1
SL		 2087 as_bad (_("missing argument"));
2088}
2089
2090
2091\f
2092/** Support for pseudo-op parsing. These are macro-like opcodes that
2093 expand into real insns by suitable fiddling with the operands. */
2094
2095/* Append the string modifier to the string contained in the argument at
2096 parsed_args[ndx]. */
2097static void
2098nios2_modify_arg (char **parsed_args, const char *modifier,
2099 int unused ATTRIBUTE_UNUSED, int ndx)
2100{
2101 char *tmp = parsed_args[ndx];
2102
2103 parsed_args[ndx]
2104 = (char *) malloc (strlen (parsed_args[ndx]) + strlen (modifier) + 1);
2105 strcpy (parsed_args[ndx], tmp);
2106 strcat (parsed_args[ndx], modifier);
2107}
2108
2109/* Modify parsed_args[ndx] by negating that argument. */
2110static void
2111nios2_negate_arg (char **parsed_args, const char *modifier ATTRIBUTE_UNUSED,
2112 int unused ATTRIBUTE_UNUSED, int ndx)
2113{
2114 char *tmp = parsed_args[ndx];
2115
2116 parsed_args[ndx]
2117 = (char *) malloc (strlen ("~(") + strlen (parsed_args[ndx]) +
2118 strlen (")+1") + 1);
2119
2120 strcpy (parsed_args[ndx], "~(");
2121 strcat (parsed_args[ndx], tmp);
2122 strcat (parsed_args[ndx], ")+1");
2123}
2124
2125/* The function nios2_swap_args swaps the pointers at indices index_1 and
2126 index_2 in the array parsed_args[] - this is used for operand swapping
2127 for comparison operations. */
2128static void
2129nios2_swap_args (char **parsed_args, const char *unused ATTRIBUTE_UNUSED,
2130 int index_1, int index_2)
2131{
2132 char *tmp;
2133 gas_assert (index_1 < NIOS2_MAX_INSN_TOKENS
2134 && index_2 < NIOS2_MAX_INSN_TOKENS);
2135 tmp = parsed_args[index_1];
2136 parsed_args[index_1] = parsed_args[index_2];
2137 parsed_args[index_2] = tmp;
2138}
2139
2140/* This function appends the string appnd to the array of strings in
2141 parsed_args num times starting at index start in the array. */
2142static void
2143nios2_append_arg (char **parsed_args, const char *appnd, int num,
2144 int start)
2145{
2146 int i, count;
2147 char *tmp;
2148
2149 gas_assert ((start + num) < NIOS2_MAX_INSN_TOKENS);
2150
2151 if (nios2_mode == NIOS2_MODE_TEST)
2152 tmp = parsed_args[start];
2153 else
2154 tmp = NULL;
2155
2156 for (i = start, count = num; count > 0; ++i, --count)
2157 parsed_args[i] = (char *) appnd;
2158
2159 gas_assert (i == (start + num));
2160 parsed_args[i] = tmp;
2161 parsed_args[i + 1] = NULL;
2162}
2163
2164/* This function inserts the string insert num times in the array
2165 parsed_args, starting at the index start. */
2166static void
2167nios2_insert_arg (char **parsed_args, const char *insert, int num,
2168 int start)
2169{
2170 int i, count;
2171
2172 gas_assert ((start + num) < NIOS2_MAX_INSN_TOKENS);
2173
2174 /* Move the existing arguments up to create space. */
2175 for (i = NIOS2_MAX_INSN_TOKENS; i - num >= start; --i)
2176 parsed_args[i] = parsed_args[i - num];
2177
2178 for (i = start, count = num; count > 0; ++i, --count)
2179 parsed_args[i] = (char *) insert;
2180}
2181
2182/* Cleanup function to free malloc'ed arg strings. */
2183static void
2184nios2_free_arg (char **parsed_args, int num ATTRIBUTE_UNUSED, int start)
2185{
2186 if (parsed_args[start])
2187 {
2188 free (parsed_args[start]);
2189 parsed_args[start] = NULL;
2190 }
2191}
2192
2193/* This function swaps the pseudo-op for a real op. */
2194static nios2_ps_insn_infoS*
2195nios2_translate_pseudo_insn (nios2_insn_infoS *insn)
2196{
2197
2198 nios2_ps_insn_infoS *ps_insn;
2199
2200 /* Find which real insn the pseudo-op transates to and
2201 switch the insn_info ptr to point to it. */
2202 ps_insn = nios2_ps_lookup (insn->insn_nios2_opcode->name);
2203
2204 if (ps_insn != NULL)
2205 {
2206 insn->insn_nios2_opcode = nios2_opcode_lookup (ps_insn->insn);
2207 insn->insn_tokens[0] = insn->insn_nios2_opcode->name;
2208 /* Modify the args so they work with the real insn. */
2209 ps_insn->arg_modifer_func ((char **) insn->insn_tokens,
2210 ps_insn->arg_modifier, ps_insn->num,
2211 ps_insn->index);
2212 }
2213 else
2214 /* we cannot recover from this. */
2215 as_fatal (_("unrecognized pseudo-instruction %s"),
2216 ps_insn->pseudo_insn);
2217 return ps_insn;
2218}
2219
2220/* Invoke the cleanup handler for pseudo-insn ps_insn on insn. */
2221static void
2222nios2_cleanup_pseudo_insn (nios2_insn_infoS *insn,
2223 nios2_ps_insn_infoS *ps_insn)
2224{
2225 if (ps_insn->arg_cleanup_func)
2226 (ps_insn->arg_cleanup_func) ((char **) insn->insn_tokens,
2227 ps_insn->num, ps_insn->index);
2228}
2229
2230const nios2_ps_insn_infoS nios2_ps_insn_info_structs[] = {
2231 /* pseudo-op, real-op, arg, arg_modifier_func, num, index, arg_cleanup_func */
2232 {"mov", "add", nios2_append_arg, "zero", 1, 3, NULL},
2233 {"movi", "addi", nios2_insert_arg, "zero", 1, 2, NULL},
2234 {"movhi", "orhi", nios2_insert_arg, "zero", 1, 2, NULL},
2235 {"movui", "ori", nios2_insert_arg, "zero", 1, 2, NULL},
2236 {"movia", "orhi", nios2_insert_arg, "zero", 1, 2, NULL},
2237 {"nop", "add", nios2_append_arg, "zero", 3, 1, NULL},
2238 {"bgt", "blt", nios2_swap_args, "", 1, 2, NULL},
2239 {"bgtu", "bltu", nios2_swap_args, "", 1, 2, NULL},
2240 {"ble", "bge", nios2_swap_args, "", 1, 2, NULL},
2241 {"bleu", "bgeu", nios2_swap_args, "", 1, 2, NULL},
2242 {"cmpgt", "cmplt", nios2_swap_args, "", 2, 3, NULL},
2243 {"cmpgtu", "cmpltu", nios2_swap_args, "", 2, 3, NULL},
2244 {"cmple", "cmpge", nios2_swap_args, "", 2, 3, NULL},
2245 {"cmpleu", "cmpgeu", nios2_swap_args, "", 2, 3, NULL},
2246 {"cmpgti", "cmpgei", nios2_modify_arg, "+1", 0, 3, nios2_free_arg},
2247 {"cmpgtui", "cmpgeui", nios2_modify_arg, "+1", 0, 3, nios2_free_arg},
2248 {"cmplei", "cmplti", nios2_modify_arg, "+1", 0, 3, nios2_free_arg},
2249 {"cmpleui", "cmpltui", nios2_modify_arg, "+1", 0, 3, nios2_free_arg},
2250 {"subi", "addi", nios2_negate_arg, "", 0, 3, nios2_free_arg}
2251 /* Add further pseudo-ops here. */
2252};
2253
2254#define NIOS2_NUM_PSEUDO_INSNS \
2255 ((sizeof(nios2_ps_insn_info_structs)/ \
2256 sizeof(nios2_ps_insn_info_structs[0])))
2257const int nios2_num_ps_insn_info_structs = NIOS2_NUM_PSEUDO_INSNS;
2258
2259\f
2260/** Assembler output support. */
2261
2262static int
2263can_evaluate_expr (nios2_insn_infoS *insn)
2264{
2265 /* Remove this check for null and the invalid insn "ori r9, 1234" seg faults. */
2266 if (!insn->insn_reloc)
2267 /* ??? Ideally we should do something other than as_fatal here as we can
2268 continue to assemble.
2269 However this function (actually the output_* functions) should not
2270 have been called in the first place once an illegal instruction had
2271 been encountered. */
2272 as_fatal (_("Invalid instruction encountered, cannot recover. No assembly attempted."));
2273
2274 if (insn->insn_reloc->reloc_expression.X_op == O_constant)
2275 return 1;
2276
2277 return 0;
2278}
2279
2280static int
2281get_expr_value (nios2_insn_infoS *insn)
2282{
2283 int value = 0;
2284
2285 if (insn->insn_reloc->reloc_expression.X_op == O_constant)
2286 value = insn->insn_reloc->reloc_expression.X_add_number;
2287 return value;
2288}
2289
2290/* Output a normal instruction. */
2291static void
2292output_insn (nios2_insn_infoS *insn)
2293{
2294 char *f;
2295 nios2_insn_relocS *reloc;
2296
2297 f = frag_more (4);
2298 /* This allocates enough space for the instruction
2299 and puts it in the current frag. */
2300 md_number_to_chars (f, insn->insn_code, 4);
2301 /* Emit debug info. */
2302 dwarf2_emit_insn (4);
2303 /* Create any fixups to be acted on later. */
2304 for (reloc = insn->insn_reloc; reloc != NULL; reloc = reloc->reloc_next)
2305 fix_new_exp (frag_now, f - frag_now->fr_literal, 4,
2306 &reloc->reloc_expression, reloc->reloc_pcrel,
2307 reloc->reloc_type);
2308}
2309
2310/* Output an unconditional branch. */
2311static void
2312output_ubranch (nios2_insn_infoS *insn)
2313{
2314 nios2_insn_relocS *reloc = insn->insn_reloc;
2315
2316 /* If the reloc is NULL, there was an error assembling the branch. */
2317 if (reloc != NULL)
2318 {
2319 symbolS *symp = reloc->reloc_expression.X_add_symbol;
2320 offsetT offset = reloc->reloc_expression.X_add_number;
2321 char *f;
2322
2323 /* Tag dwarf2 debug info to the address at the start of the insn.
2324 We must do it before frag_var() below closes off the frag. */
2325 dwarf2_emit_insn (0);
2326
2327 /* We create a machine dependent frag which can grow
2328 to accommodate the largest possible instruction sequence
2329 this may generate. */
2330 f = frag_var (rs_machine_dependent,
2331 UBRANCH_MAX_SIZE, 4, UBRANCH_SUBTYPE (0),
2332 symp, offset, NULL);
2333
2334 md_number_to_chars (f, insn->insn_code, 4);
2335
2336 /* We leave fixup generation to md_convert_frag. */
2337 }
2338}
2339
2340/* Output a conditional branch. */
2341static void
2342output_cbranch (nios2_insn_infoS *insn)
2343{
2344 nios2_insn_relocS *reloc = insn->insn_reloc;
2345
2346 /* If the reloc is NULL, there was an error assembling the branch. */
2347 if (reloc != NULL)
2348 {
2349 symbolS *symp = reloc->reloc_expression.X_add_symbol;
2350 offsetT offset = reloc->reloc_expression.X_add_number;
2351 char *f;
2352
2353 /* Tag dwarf2 debug info to the address at the start of the insn.
2354 We must do it before frag_var() below closes off the frag. */
2355 dwarf2_emit_insn (0);
2356
2357 /* We create a machine dependent frag which can grow
2358 to accommodate the largest possible instruction sequence
2359 this may generate. */
2360 f = frag_var (rs_machine_dependent,
2361 CBRANCH_MAX_SIZE, 4, CBRANCH_SUBTYPE (0),
2362 symp, offset, NULL);
2363
2364 md_number_to_chars (f, insn->insn_code, 4);
2365
2366 /* We leave fixup generation to md_convert_frag. */
2367 }
2368}
2369
2370/* Output a call sequence. Since calls are not pc-relative for NIOS2,
2371 but are page-relative, we cannot tell at any stage in assembly
2372 whether a call will be out of range since a section may be linked
2373 at any address. So if we are relaxing, we convert all call instructions
2374 to long call sequences, and rely on the linker to relax them back to
2375 short calls. */
2376static void
2377output_call (nios2_insn_infoS *insn)
2378{
2379 /* This allocates enough space for the instruction
2380 and puts it in the current frag. */
2381 char *f = frag_more (12);
2382 nios2_insn_relocS *reloc = insn->insn_reloc;
2383
2384 md_number_to_chars (f, OP_MATCH_ORHI | 0x00400000, 4);
2385 dwarf2_emit_insn (4);
2386 fix_new_exp (frag_now, f - frag_now->fr_literal, 4,
2387 &reloc->reloc_expression, 0, BFD_RELOC_NIOS2_HI16);
2388 md_number_to_chars (f + 4, OP_MATCH_ORI | 0x08400000, 4);
2389 dwarf2_emit_insn (4);
2390 fix_new_exp (frag_now, f - frag_now->fr_literal + 4, 4,
2391 &reloc->reloc_expression, 0, BFD_RELOC_NIOS2_LO16);
2392 md_number_to_chars (f + 8, OP_MATCH_CALLR | 0x08000000, 4);
2393 dwarf2_emit_insn (4);
2394}
2395
2396/* Output an addi - will silently convert to
2397 orhi if rA = r0 and (expr & 0xffff0000) == 0. */
2398static void
2399output_addi (nios2_insn_infoS *insn)
2400{
2401 if (can_evaluate_expr (insn))
2402 {
2403 int expr_val = get_expr_value (insn);
2404 if (GET_INSN_FIELD (RRS, insn->insn_code) == 0
2405 && (expr_val & 0xffff) == 0
2406 && expr_val != 0)
2407 {
2408 /* We really want a movhi (orhi) here. */
2409 insn->insn_code = (insn->insn_code & ~OP_MATCH_ADDI) | OP_MATCH_ORHI;
2410 insn->insn_reloc->reloc_expression.X_add_number =
2411 (insn->insn_reloc->reloc_expression.X_add_number >> 16) & 0xffff;
2412 insn->insn_reloc->reloc_type = BFD_RELOC_NIOS2_U16;
2413 }
2414 }
2415
2416 /* Output an instruction. */
2417 output_insn (insn);
2418}
2419
2420static void
2421output_andi (nios2_insn_infoS *insn)
2422{
2423 if (can_evaluate_expr (insn))
2424 {
2425 int expr_val = get_expr_value (insn);
2426 if (expr_val != 0 && (expr_val & 0xffff) == 0)
2427 {
2428 /* We really want a movhi (orhi) here. */
2429 insn->insn_code = (insn->insn_code & ~OP_MATCH_ANDI) | OP_MATCH_ANDHI;
2430 insn->insn_reloc->reloc_expression.X_add_number =
2431 (insn->insn_reloc->reloc_expression.X_add_number >> 16) & 0xffff;
2432 insn->insn_reloc->reloc_type = BFD_RELOC_NIOS2_U16;
2433 }
2434 }
2435
2436 /* Output an instruction. */
2437 output_insn (insn);
2438}
2439
2440static void
2441output_ori (nios2_insn_infoS *insn)
2442{
2443 if (can_evaluate_expr (insn))
2444 {
2445 int expr_val = get_expr_value (insn);
2446 if (expr_val != 0 && (expr_val & 0xffff) == 0)
2447 {
2448 /* We really want a movhi (orhi) here. */
2449 insn->insn_code = (insn->insn_code & ~OP_MATCH_ORI) | OP_MATCH_ORHI;
2450 insn->insn_reloc->reloc_expression.X_add_number =
2451 (insn->insn_reloc->reloc_expression.X_add_number >> 16) & 0xffff;
2452 insn->insn_reloc->reloc_type = BFD_RELOC_NIOS2_U16;
2453 }
2454 }
2455
2456 /* Output an instruction. */
2457 output_insn (insn);
2458}
2459
2460static void
2461output_xori (nios2_insn_infoS *insn)
2462{
2463 if (can_evaluate_expr (insn))
2464 {
2465 int expr_val = get_expr_value (insn);
2466 if (expr_val != 0 && (expr_val & 0xffff) == 0)
2467 {
2468 /* We really want a movhi (orhi) here. */
2469 insn->insn_code = (insn->insn_code & ~OP_MATCH_XORI) | OP_MATCH_XORHI;
2470 insn->insn_reloc->reloc_expression.X_add_number =
2471 (insn->insn_reloc->reloc_expression.X_add_number >> 16) & 0xffff;
2472 insn->insn_reloc->reloc_type = BFD_RELOC_NIOS2_U16;
2473 }
2474 }
2475
2476 /* Output an instruction. */
2477 output_insn (insn);
2478}
2479
2480
2481/* Output a movhi/addi pair for the movia pseudo-op. */
2482static void
2483output_movia (nios2_insn_infoS *insn)
2484{
2485 /* This allocates enough space for the instruction
2486 and puts it in the current frag. */
2487 char *f = frag_more (8);
2488 nios2_insn_relocS *reloc = insn->insn_reloc;
2489 unsigned long reg_index = GET_INSN_FIELD (IRT, insn->insn_code);
2490
2491 /* If the reloc is NULL, there was an error assembling the movia. */
2492 if (reloc != NULL)
2493 {
2494 md_number_to_chars (f, insn->insn_code, 4);
2495 dwarf2_emit_insn (4);
2496 md_number_to_chars (f + 4,
2497 (OP_MATCH_ADDI | (reg_index << OP_SH_IRT)
2498 | (reg_index << OP_SH_IRS)),
2499 4);
2500 dwarf2_emit_insn (4);
2501 fix_new (frag_now, f - frag_now->fr_literal, 4,
2502 reloc->reloc_expression.X_add_symbol,
2503 reloc->reloc_expression.X_add_number, 0,
2504 BFD_RELOC_NIOS2_HIADJ16);
2505 fix_new (frag_now, f + 4 - frag_now->fr_literal, 4,
2506 reloc->reloc_expression.X_add_symbol,
2507 reloc->reloc_expression.X_add_number, 0, BFD_RELOC_NIOS2_LO16);
2508 }
2509}
2510
2511
2512\f
2513/** External interfaces. */
2514
2515/* The following functions are called by machine-independent parts of
2516 the assembler. */
2517int
2518md_parse_option (int c, char *arg ATTRIBUTE_UNUSED)
2519{
2520 switch (c)
2521 {
2522 case 'r':
2523 /* Hidden option for self-test mode. */
2524 nios2_mode = NIOS2_MODE_TEST;
2525 break;
2526 case OPTION_RELAX_ALL:
2527 nios2_as_options.relax = relax_all;
2528 break;
2529 case OPTION_NORELAX:
2530 nios2_as_options.relax = relax_none;
2531 break;
2532 case OPTION_RELAX_SECTION:
2533 nios2_as_options.relax = relax_section;
2534 break;
2535 case OPTION_EB:
2536 target_big_endian = 1;
2537 break;
2538 case OPTION_EL:
2539 target_big_endian = 0;
2540 break;
2541 default:
2542 return 0;
2543 break;
2544 }
2545
2546 return 1;
2547}
2548
2549/* Implement TARGET_FORMAT. We can choose to be big-endian or
2550 little-endian at runtime based on a switch. */
2551const char *
2552nios2_target_format (void)
2553{
2554 return target_big_endian ? "elf32-bignios2" : "elf32-littlenios2";
2555}
2556
2557/* Machine-dependent usage message. */
2558void
2559md_show_usage (FILE *stream)
2560{
2561 fprintf (stream, " NIOS2 options:\n"
2562 " -relax-all replace all branch and call "
2563 "instructions with jmp and callr sequences\n"
2564 " -relax-section replace identified out of range "
2565 "branches with jmp sequences (default)\n"
2566 " -no-relax do not replace any branches or calls\n"
2567 " -EB force big-endian byte ordering\n"
2568 " -EL force little-endian byte ordering\n");
2569}
2570
2571/* This function is called once, at assembler startup time.
2572 It should set up all the tables, etc. that the MD part of the
2573 assembler will need. */
2574void
2575md_begin (void)
2576{
2577 int i;
2578 const char *inserted;
2579
2580 /* Create and fill a hashtable for the Nios II opcodes, registers and
2581 arguments. */
2582 nios2_opcode_hash = hash_new ();
2583 nios2_reg_hash = hash_new ();
2584 nios2_arg_hash = hash_new ();
2585 nios2_ps_hash = hash_new ();
2586
2587 for (i = 0; i < NUMOPCODES; ++i)
2588 {
2589 inserted
2590 = hash_insert (nios2_opcode_hash, nios2_opcodes[i].name,
2591 (PTR) & nios2_opcodes[i]);
2592 if (inserted != NULL)
2593 {
2594 fprintf (stderr, _("internal error: can't hash `%s': %s\n"),
2595 nios2_opcodes[i].name, inserted);
2596 /* Probably a memory allocation problem? Give up now. */
2597 as_fatal (_("Broken assembler. No assembly attempted."));
2598 }
2599 }
2600
2601 for (i = 0; i < nios2_num_regs; ++i)
2602 {
2603 inserted
2604 = hash_insert (nios2_reg_hash, nios2_regs[i].name,
2605 (PTR) & nios2_regs[i]);
2606 if (inserted != NULL)
2607 {
2608 fprintf (stderr, _("internal error: can't hash `%s': %s\n"),
2609 nios2_regs[i].name, inserted);
2610 /* Probably a memory allocation problem? Give up now. */
2611 as_fatal (_("Broken assembler. No assembly attempted."));
2612 }
2613
2614 }
2615
2616 for (i = 0; i < nios2_num_arg_info_structs; ++i)
2617 {
2618 inserted
2619 = hash_insert (nios2_arg_hash, nios2_arg_info_structs[i].args,
2620 (PTR) & nios2_arg_info_structs[i]);
2621 if (inserted != NULL)
2622 {
2623 fprintf (stderr, _("internal error: can't hash `%s': %s\n"),
2624 nios2_arg_info_structs[i].args, inserted);
2625 /* Probably a memory allocation problem? Give up now. */
2626 as_fatal (_("Broken assembler. No assembly attempted."));
2627 }
2628 }
2629
2630 for (i = 0; i < nios2_num_ps_insn_info_structs; ++i)
2631 {
2632 inserted
2633 = hash_insert (nios2_ps_hash, nios2_ps_insn_info_structs[i].pseudo_insn,
2634 (PTR) & nios2_ps_insn_info_structs[i]);
2635 if (inserted != NULL)
2636 {
2637 fprintf (stderr, _("internal error: can't hash `%s': %s\n"),
2638 nios2_ps_insn_info_structs[i].pseudo_insn, inserted);
2639 /* Probably a memory allocation problem? Give up now. */
2640 as_fatal (_("Broken assembler. No assembly attempted."));
2641 }
2642 }
2643
2644 /* Assembler option defaults. */
2645 nios2_as_options.noat = FALSE;
2646 nios2_as_options.nobreak = FALSE;
2647
2648 /* Debug information is incompatible with relaxation. */
2649 if (debug_type != DEBUG_UNSPECIFIED)
2650 nios2_as_options.relax = relax_none;
2651
2652 /* Initialize the alignment data. */
2653 nios2_current_align_seg = now_seg;
2654 nios2_last_label = NULL;
2655 nios2_current_align = 0;
2656}
2657
2658
2659/* Assembles a single line of Nios II assembly language. */
2660void
2661md_assemble (char *op_str)
2662{
2663 char *argstr;
2664 char *op_strdup = NULL;
2665 nios2_arg_infoS *arg_info;
2666 unsigned long saved_pinfo = 0;
2667 nios2_insn_infoS thisinsn;
2668 nios2_insn_infoS *insn = &thisinsn;
2669
2670 /* Make sure we are aligned on a 4-byte boundary. */
2671 if (nios2_current_align < 2)
2672 nios2_align (2, NULL, nios2_last_label);
2673 else if (nios2_current_align > 2)
2674 nios2_current_align = 2;
2675 nios2_last_label = NULL;
2676
2677 /* We don't want to clobber to op_str
2678 because we want to be able to use it in messages. */
2679 op_strdup = strdup (op_str);
2680 insn->insn_tokens[0] = strtok (op_strdup, " ");
2681 argstr = strtok (NULL, "");
2682
2683 /* Assemble the opcode. */
2684 insn->insn_nios2_opcode = nios2_opcode_lookup (insn->insn_tokens[0]);
2685 insn->insn_reloc = NULL;
2686
2687 if (insn->insn_nios2_opcode != NULL)
2688 {
2689 nios2_ps_insn_infoS *ps_insn = NULL;
2690 /* Set the opcode for the instruction. */
2691 insn->insn_code = insn->insn_nios2_opcode->match;
2692
2693 /* Parse the arguments pointed to by argstr. */
2694 if (nios2_mode == NIOS2_MODE_ASSEMBLE)
2695 nios2_parse_args (insn, argstr, insn->insn_nios2_opcode->args,
2696 (char **) &insn->insn_tokens[1]);
2697 else
2698 nios2_parse_args (insn, argstr, insn->insn_nios2_opcode->args_test,
2699 (char **) &insn->insn_tokens[1]);
2700
2701 /* We need to preserve the MOVIA macro as this is clobbered by
2702 translate_pseudo_insn. */
2703 if (insn->insn_nios2_opcode->pinfo == NIOS2_INSN_MACRO_MOVIA)
2704 saved_pinfo = NIOS2_INSN_MACRO_MOVIA;
2705 /* If the instruction is an pseudo-instruction, we want to replace it
2706 with its real equivalent, and then continue. */
2707 if ((insn->insn_nios2_opcode->pinfo & NIOS2_INSN_MACRO)
2708 == NIOS2_INSN_MACRO)
2709 ps_insn = nios2_translate_pseudo_insn (insn);
2710
2711 /* Find the assemble function, and call it. */
2712 arg_info = nios2_arg_lookup (insn->insn_nios2_opcode->args);
2713 if (arg_info != NULL)
2714 {
2715 arg_info->assemble_args_func (insn);
2716
2717 if (nios2_as_options.relax != relax_none
2718 && !nios2_as_options.noat
2719 && insn->insn_nios2_opcode->pinfo & NIOS2_INSN_UBRANCH)
2720 output_ubranch (insn);
2721 else if (nios2_as_options.relax != relax_none
2722 && !nios2_as_options.noat
2723 && insn->insn_nios2_opcode->pinfo & NIOS2_INSN_CBRANCH)
2724 output_cbranch (insn);
2725 else if (nios2_as_options.relax == relax_all
2726 && !nios2_as_options.noat
2727 && insn->insn_nios2_opcode->pinfo & NIOS2_INSN_CALL
2728 && insn->insn_reloc
2729 && insn->insn_reloc->reloc_type == BFD_RELOC_NIOS2_CALL26)
2730 output_call (insn);
2731 else if (insn->insn_nios2_opcode->pinfo & NIOS2_INSN_ANDI)
2732 output_andi (insn);
2733 else if (insn->insn_nios2_opcode->pinfo & NIOS2_INSN_ORI)
2734 output_ori (insn);
2735 else if (insn->insn_nios2_opcode->pinfo & NIOS2_INSN_XORI)
2736 output_xori (insn);
2737 else if (insn->insn_nios2_opcode->pinfo & NIOS2_INSN_ADDI)
2738 output_addi (insn);
2739 else if (saved_pinfo == NIOS2_INSN_MACRO_MOVIA)
2740 output_movia (insn);
2741 else
2742 output_insn (insn);
2743 if (ps_insn)
2744 nios2_cleanup_pseudo_insn (insn, ps_insn);
2745 }
2746 else
2747 {
2748 /* The assembler is broken. */
2749 fprintf (stderr,
2750 _("internal error: %s is not a valid argument syntax\n"),
2751 insn->insn_nios2_opcode->args);
2752 /* Probably a memory allocation problem. Give up now. */
2753 as_fatal (_("Broken assembler. No assembly attempted."));
2754 }
2755 }
2756 else
2757 /* Unrecognised instruction - error. */
2758 as_bad (_("unrecognised instruction %s"), insn->insn_tokens[0]);
2759
2760 /* Don't leak memory. */
2761 free (op_strdup);
2762}
2763
2764/* Round up section size. */
2765valueT
2766md_section_align (asection *seg ATTRIBUTE_UNUSED, valueT size)
2767{
2768 /* I think byte alignment is fine here. */
2769 return size;
2770}
2771
2772/* Implement TC_FORCE_RELOCATION. */
2773int
2774nios2_force_relocation (fixS *fixp)
2775{
2776 if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2777 || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY
2778 || fixp->fx_r_type == BFD_RELOC_NIOS2_ALIGN)
2779 return 1;
2780
2781 return generic_force_reloc (fixp);
2782}
2783
2784/* Implement tc_fix_adjustable. */
2785int
2786nios2_fix_adjustable (fixS *fixp)
2787{
2788 if (fixp->fx_addsy == NULL)
2789 return 1;
2790
2791#ifdef OBJ_ELF
2792 /* Prevent all adjustments to global symbols. */
2793 if (OUTPUT_FLAVOR == bfd_target_elf_flavour
2794 && (S_IS_EXTERNAL (fixp->fx_addsy) || S_IS_WEAK (fixp->fx_addsy)))
2795 return 0;
2796#endif
2797 if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2798 || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2799 return 0;
2800
2801 /* Preserve relocations against symbols with function type. */
2802 if (symbol_get_bfdsym (fixp->fx_addsy)->flags & BSF_FUNCTION)
2803 return 0;
2804
2805 /* Don't allow symbols to be discarded on GOT related relocs. */
2806 if (fixp->fx_r_type == BFD_RELOC_NIOS2_GOT16
2807 || fixp->fx_r_type == BFD_RELOC_NIOS2_CALL16
2808 || fixp->fx_r_type == BFD_RELOC_NIOS2_GOTOFF_LO
2809 || fixp->fx_r_type == BFD_RELOC_NIOS2_GOTOFF_HA
2810 || fixp->fx_r_type == BFD_RELOC_NIOS2_TLS_GD16
2811 || fixp->fx_r_type == BFD_RELOC_NIOS2_TLS_LDM16
2812 || fixp->fx_r_type == BFD_RELOC_NIOS2_TLS_LDO16
2813 || fixp->fx_r_type == BFD_RELOC_NIOS2_TLS_IE16
2814 || fixp->fx_r_type == BFD_RELOC_NIOS2_TLS_LE16
2815 || fixp->fx_r_type == BFD_RELOC_NIOS2_TLS_DTPMOD
2816 || fixp->fx_r_type == BFD_RELOC_NIOS2_TLS_DTPREL
2817 || fixp->fx_r_type == BFD_RELOC_NIOS2_TLS_TPREL
2818 || fixp->fx_r_type == BFD_RELOC_NIOS2_GOTOFF)
2819 return 0;
2820
2821 return 1;
2822}
2823
2824/* Implement tc_frob_symbol. This is called in adjust_reloc_syms;
2825 it is used to remove *ABS* references from the symbol table. */
2826int
2827nios2_frob_symbol (symbolS *symp)
2828{
2829 if ((OUTPUT_FLAVOR == bfd_target_elf_flavour
2830 && symp == section_symbol (absolute_section))
2831 || !S_IS_DEFINED (symp))
2832 return 1;
2833 else
2834 return 0;
2835}
2836
2837/* The function tc_gen_reloc creates a relocation structure for the
2838 fixup fixp, and returns a pointer to it. This structure is passed
2839 to bfd_install_relocation so that it can be written to the object
2840 file for linking. */
2841arelent *
2842tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
2843{
2844 arelent *reloc = (arelent *) xmalloc (sizeof (arelent));
2845 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2846 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2847
2848 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2849 reloc->addend = fixp->fx_offset; /* fixp->fx_addnumber; */
2850
2851 if (fixp->fx_pcrel)
2852 {
2853 switch (fixp->fx_r_type)
2854 {
2855 case BFD_RELOC_16:
2856 fixp->fx_r_type = BFD_RELOC_16_PCREL;
2857 break;
2858 case BFD_RELOC_NIOS2_LO16:
2859 fixp->fx_r_type = BFD_RELOC_NIOS2_PCREL_LO;
2860 break;
2861 case BFD_RELOC_NIOS2_HIADJ16:
2862 fixp->fx_r_type = BFD_RELOC_NIOS2_PCREL_HA;
2863 break;
2864 default:
2865 break;
2866 }
2867 }
2868
2869 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
2870 if (reloc->howto == NULL)
2871 {
2872 as_bad_where (fixp->fx_file, fixp->fx_line,
2873 _("can't represent relocation type %s"),
2874 bfd_get_reloc_code_name (fixp->fx_r_type));
2875
2876 /* Set howto to a garbage value so that we can keep going. */
2877 reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
2878 gas_assert (reloc->howto != NULL);
2879 }
2880 return reloc;
2881}
2882
2883long
2884md_pcrel_from (fixS *fixP ATTRIBUTE_UNUSED)
2885{
2886 return 0;
2887}
2888
2889/* Called just before the assembler exits. */
2890void
2891md_end ()
2892{
2893 /* FIXME - not yet implemented */
2894}
2895
2896/* Under ELF we need to default _GLOBAL_OFFSET_TABLE.
2897 Otherwise we have no need to default values of symbols. */
2898symbolS *
2899md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
2900{
2901#ifdef OBJ_ELF
2902 if (name[0] == '_' && name[1] == 'G'
2903 && strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0)
2904 {
2905 if (!GOT_symbol)
2906 {
2907 if (symbol_find (name))
2908 as_bad ("GOT already in the symbol table");
2909
2910 GOT_symbol = symbol_new (name, undefined_section,
2911 (valueT) 0, &zero_address_frag);
2912 }
2913
2914 return GOT_symbol;
2915 }
2916#endif
2917
2918 return 0;
2919}
2920
2921/* Implement tc_frob_label. */
2922void
2923nios2_frob_label (symbolS *lab)
2924{
2925 /* Emit dwarf information. */
2926 dwarf2_emit_label (lab);
2927
2928 /* Update the label's address with the current output pointer. */
2929 symbol_set_frag (lab, frag_now);
2930 S_SET_VALUE (lab, (valueT) frag_now_fix ());
2931
2932 /* Record this label for future adjustment after we find out what
2933 kind of data it references, and the required alignment therewith. */
2934 nios2_last_label = lab;
2935}
2936
2937/* Implement md_cons_align. */
2938void
2939nios2_cons_align (int size)
2940{
2941 int log_size = 0;
2942 const char *pfill = NULL;
2943
2944 while ((size >>= 1) != 0)
2945 ++log_size;
2946
2947 if (subseg_text_p (now_seg))
2948 pfill = (const char *) &nop;
2949 else
2950 pfill = NULL;
2951
2952 if (nios2_auto_align_on)
2953 nios2_align (log_size, pfill, NULL);
2954
2955 nios2_last_label = NULL;
2956}
2957
2958/* Map 's' to SHF_NIOS2_GPREL. */
2959/* This is from the Alpha code tc-alpha.c. */
2960int
2961nios2_elf_section_letter (int letter, char **ptr_msg)
2962{
2963 if (letter == 's')
2964 return SHF_NIOS2_GPREL;
2965
2966 *ptr_msg = _("Bad .section directive: want a,s,w,x,M,S,G,T in string");
2967 return -1;
2968}
2969
2970/* Map SHF_ALPHA_GPREL to SEC_SMALL_DATA. */
2971/* This is from the Alpha code tc-alpha.c. */
2972flagword
2973nios2_elf_section_flags (flagword flags, int attr, int type ATTRIBUTE_UNUSED)
2974{
2975 if (attr & SHF_NIOS2_GPREL)
2976 flags |= SEC_SMALL_DATA;
2977 return flags;
2978}
2979
2980/* Implement TC_PARSE_CONS_EXPRESSION to handle %tls_ldo(...) */
2981static int nios2_tls_ldo_reloc;
2982
2983void
2984nios2_cons (expressionS *exp, int size)
2985{
2986 nios2_tls_ldo_reloc = 0;
2987
2988 SKIP_WHITESPACE ();
2989 if (input_line_pointer[0] == '%')
2990 {
2991 if (strprefix (input_line_pointer + 1, "tls_ldo"))
2992 {
2993 if (size != 4)
2994 as_bad (_("Illegal operands: %%tls_ldo in %d-byte data field"),
2995 size);
2996 else
2997 {
2998 input_line_pointer += 8;
2999 nios2_tls_ldo_reloc = 1;
3000 }
3001 }
3002 if (nios2_tls_ldo_reloc)
3003 {
3004 SKIP_WHITESPACE ();
3005 if (input_line_pointer[0] != '(')
3006 as_bad (_("Illegal operands: %%tls_ldo requires arguments in ()"));
3007 else
3008 {
3009 int c;
3010 char *end = ++input_line_pointer;
3011 int npar = 0;
3012
3013 for (c = *end; !is_end_of_line[c]; end++, c = *end)
3014 if (c == '(')
3015 npar++;
3016 else if (c == ')')
3017 {
3018 if (!npar)
3019 break;
3020 npar--;
3021 }
3022
3023 if (c != ')')
3024 as_bad (_("Illegal operands: %%tls_ldo requires arguments in ()"));
3025 else
3026 {
3027 *end = '\0';
3028 expression (exp);
3029 *end = c;
3030 if (input_line_pointer != end)
3031 as_bad (_("Illegal operands: %%tls_ldo requires arguments in ()"));
3032 else
3033 {
3034 input_line_pointer++;
3035 SKIP_WHITESPACE ();
3036 c = *input_line_pointer;
3037 if (! is_end_of_line[c] && c != ',')
3038 as_bad (_("Illegal operands: garbage after %%tls_ldo()"));
3039 }
3040 }
3041 }
3042 }
3043 }
3044 if (!nios2_tls_ldo_reloc)
3045 expression (exp);
3046}
3047
3048/* Implement TC_CONS_FIX_NEW. */
3049void
3050nios2_cons_fix_new (fragS *frag, int where, unsigned int nbytes,
3051 expressionS *exp)
3052{
3053 bfd_reloc_code_real_type r;
3054
3055 r = (nbytes == 1 ? BFD_RELOC_8
3056 : (nbytes == 2 ? BFD_RELOC_16
3057 : (nbytes == 4 ? BFD_RELOC_32 : BFD_RELOC_64)));
3058
3059 if (nios2_tls_ldo_reloc)
3060 r = BFD_RELOC_NIOS2_TLS_DTPREL;
3061
3062 fix_new_exp (frag, where, (int) nbytes, exp, 0, r);
3063 nios2_tls_ldo_reloc = 0;
3064}
3065
3066/* Implement HANDLE_ALIGN. */
3067void
3068nios2_handle_align (fragS *fragp)
3069{
3070 /* If we are expecting to relax in the linker, then we must output a
3071 relocation to tell the linker we are aligning code. */
3072 if (nios2_as_options.relax == relax_all
3073 && (fragp->fr_type == rs_align || fragp->fr_type == rs_align_code)
3074 && fragp->fr_address + fragp->fr_fix > 0
3075 && fragp->fr_offset > 1
3076 && now_seg != bss_section)
3077 fix_new (fragp, fragp->fr_fix, 0, &abs_symbol, fragp->fr_offset, 0,
3078 BFD_RELOC_NIOS2_ALIGN);
3079}
3080
3081/* Implement tc_regname_to_dw2regnum, to convert REGNAME to a DWARF-2
3082 register number. */
3083int
3084nios2_regname_to_dw2regnum (char *regname)
3085{
3086 struct nios2_reg *r = nios2_reg_lookup (regname);
3087 if (r == NULL)
3088 return -1;
3089 return r->index;
3090}
3091
3092/* Implement tc_cfi_frame_initial_instructions, to initialize the DWARF-2
3093 unwind information for this procedure. */
3094void
3095nios2_frame_initial_instructions (void)
3096{
3097 cfi_add_CFA_def_cfa (27, 0);
3098}
GDB Binutils - Deliverables
This page took 0.159309 seconds and 4 git commands to generate.