?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Set OSABI field back to 0 (SysV), to avoid interoperability problems
[nacl-binutils.git] / gas / config / tc-frv.c
blob5ef9971921a1eda7919dba111ac283c884f69b01
1 /* tc-frv.c -- Assembler for the Fujitsu FRV.
2 Copyright 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation. Inc.
4
5 This file is part of GAS, the GNU Assembler.
6
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
11
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street - Fifth Floor,
20 Boston, MA 02110-1301, USA. */
21
22 #include "as.h"
23 #include "subsegs.h"
24 #include "symcat.h"
25 #include "opcodes/frv-desc.h"
26 #include "opcodes/frv-opc.h"
27 #include "cgen.h"
28 #include "libbfd.h"
29 #include "elf/common.h"
30 #include "elf/frv.h"
31
32 /* Structure to hold all of the different components describing
33 an individual instruction. */
34 typedef struct
35 {
36 const CGEN_INSN * insn;
37 const CGEN_INSN * orig_insn;
38 CGEN_FIELDS fields;
39 #if CGEN_INT_INSN_P
40 CGEN_INSN_INT buffer [1];
41 #define INSN_VALUE(buf) (*(buf))
42 #else
43 unsigned char buffer [CGEN_MAX_INSN_SIZE];
44 #define INSN_VALUE(buf) (buf)
45 #endif
46 char * addr;
47 fragS * frag;
48 int num_fixups;
49 fixS * fixups [GAS_CGEN_MAX_FIXUPS];
50 int indices [MAX_OPERAND_INSTANCES];
51 }
52 frv_insn;
53
54 enum vliw_insn_type
55 {
56 VLIW_GENERIC_TYPE, /* Don't care about this insn. */
57 VLIW_BRANCH_TYPE, /* A Branch. */
58 VLIW_LABEL_TYPE, /* A Label. */
59 VLIW_NOP_TYPE, /* A NOP. */
60 VLIW_BRANCH_HAS_NOPS /* A Branch that requires NOPS. */
61 };
62
63 /* We're going to use these in the fr_subtype field to mark
64 whether to keep inserted nops. */
65
66 #define NOP_KEEP 1 /* Keep these NOPS. */
67 #define NOP_DELETE 2 /* Delete these NOPS. */
68
69 #define DO_COUNT TRUE
70 #define DONT_COUNT FALSE
71
72 /* A list of insns within a VLIW insn. */
73 struct vliw_insn_list
74 {
75 /* The type of this insn. */
76 enum vliw_insn_type type;
77
78 /* The corresponding gas insn information. */
79 const CGEN_INSN *insn;
80
81 /* For branches and labels, the symbol that is referenced. */
82 symbolS *sym;
83
84 /* For branches, the frag containing the single nop that was generated. */
85 fragS *snop_frag;
86
87 /* For branches, the frag containing the double nop that was generated. */
88 fragS *dnop_frag;
89
90 /* Pointer to raw data for this insn. */
91 char *address;
92
93 /* Next insn in list. */
94 struct vliw_insn_list *next;
95 };
96
97 static struct vliw_insn_list single_nop_insn = {
98 VLIW_NOP_TYPE, NULL, NULL, NULL, NULL, NULL, NULL };
99
100 static struct vliw_insn_list double_nop_insn = {
101 VLIW_NOP_TYPE, NULL, NULL, NULL, NULL, NULL, NULL };
102
103 struct vliw_chain
104 {
105 int num;
106 int insn_count;
107 struct vliw_insn_list *insn_list;
108 struct vliw_chain *next;
109 };
110
111 static struct vliw_chain *vliw_chain_top;
112 static struct vliw_chain *current_vliw_chain;
113 static struct vliw_chain *previous_vliw_chain;
114 static struct vliw_insn_list *current_vliw_insn;
115
116 const char comment_chars[] = ";";
117 const char line_comment_chars[] = "#";
118 const char line_separator_chars[] = "!";
119 const char EXP_CHARS[] = "eE";
120 const char FLT_CHARS[] = "dD";
121
122 static FRV_VLIW vliw;
123
124 /* Default machine */
125
126 #ifdef DEFAULT_CPU_FRV
127 #define DEFAULT_MACHINE bfd_mach_frv
128 #define DEFAULT_FLAGS EF_FRV_CPU_GENERIC
129
130 #else
131 #ifdef DEFAULT_CPU_FR300
132 #define DEFAULT_MACHINE bfd_mach_fr300
133 #define DEFAULT_FLAGS EF_FRV_CPU_FR300
134
135 #else
136 #ifdef DEFAULT_CPU_SIMPLE
137 #define DEFAULT_MACHINE bfd_mach_frvsimple
138 #define DEFAULT_FLAGS EF_FRV_CPU_SIMPLE
139
140 #else
141 #ifdef DEFAULT_CPU_TOMCAT
142 #define DEFAULT_MACHINE bfd_mach_frvtomcat
143 #define DEFAULT_FLAGS EF_FRV_CPU_TOMCAT
144
145 #else
146 #ifdef DEFAULT_CPU_FR400
147 #define DEFAULT_MACHINE bfd_mach_fr400
148 #define DEFAULT_FLAGS EF_FRV_CPU_FR400
149
150 #else
151 #ifdef DEFAULT_CPU_FR550
152 #define DEFAULT_MACHINE bfd_mach_fr550
153 #define DEFAULT_FLAGS EF_FRV_CPU_FR550
154
155 #else
156 #define DEFAULT_MACHINE bfd_mach_fr500
157 #define DEFAULT_FLAGS EF_FRV_CPU_FR500
158 #endif
159 #endif
160 #endif
161 #endif
162 #endif
163 #endif
164
165 #ifdef TE_LINUX
166 # define DEFAULT_FDPIC EF_FRV_FDPIC
167 #else
168 # define DEFAULT_FDPIC 0
169 #endif
170
171 static unsigned long frv_mach = bfd_mach_frv;
172 static bfd_boolean fr400_audio;
173
174 /* Flags to set in the elf header */
175 static flagword frv_flags = DEFAULT_FLAGS | DEFAULT_FDPIC;
176
177 static int frv_user_set_flags_p = 0;
178 static int frv_pic_p = 0;
179 static const char *frv_pic_flag = DEFAULT_FDPIC ? "-mfdpic" : (const char *)0;
180
181 /* Print tomcat-specific debugging info. */
182 static int tomcat_debug = 0;
183
184 /* Tomcat-specific NOP statistics. */
185 static int tomcat_stats = 0;
186 static int tomcat_doubles = 0;
187 static int tomcat_singles = 0;
188
189 /* Forward reference to static functions */
190 static void frv_set_flags PARAMS ((int));
191 static void frv_pic_ptr PARAMS ((int));
192 static void frv_frob_file_section PARAMS ((bfd *, asection *, PTR));
193
194 /* The target specific pseudo-ops which we support. */
195 const pseudo_typeS md_pseudo_table[] =
196 {
197 { "eflags", frv_set_flags, 0 },
198 { "word", cons, 4 },
199 { "picptr", frv_pic_ptr, 4 },
200 { NULL, NULL, 0 }
201 };
202
203 \f
204 #define FRV_SHORTOPTS "G:"
205 const char * md_shortopts = FRV_SHORTOPTS;
206
207 #define OPTION_GPR_32 (OPTION_MD_BASE)
208 #define OPTION_GPR_64 (OPTION_MD_BASE + 1)
209 #define OPTION_FPR_32 (OPTION_MD_BASE + 2)
210 #define OPTION_FPR_64 (OPTION_MD_BASE + 3)
211 #define OPTION_SOFT_FLOAT (OPTION_MD_BASE + 4)
212 #define OPTION_DWORD_YES (OPTION_MD_BASE + 5)
213 #define OPTION_DWORD_NO (OPTION_MD_BASE + 6)
214 #define OPTION_DOUBLE (OPTION_MD_BASE + 7)
215 #define OPTION_NO_DOUBLE (OPTION_MD_BASE + 8)
216 #define OPTION_MEDIA (OPTION_MD_BASE + 9)
217 #define OPTION_NO_MEDIA (OPTION_MD_BASE + 10)
218 #define OPTION_CPU (OPTION_MD_BASE + 11)
219 #define OPTION_PIC (OPTION_MD_BASE + 12)
220 #define OPTION_BIGPIC (OPTION_MD_BASE + 13)
221 #define OPTION_LIBPIC (OPTION_MD_BASE + 14)
222 #define OPTION_MULADD (OPTION_MD_BASE + 15)
223 #define OPTION_NO_MULADD (OPTION_MD_BASE + 16)
224 #define OPTION_TOMCAT_DEBUG (OPTION_MD_BASE + 17)
225 #define OPTION_TOMCAT_STATS (OPTION_MD_BASE + 18)
226 #define OPTION_PACK (OPTION_MD_BASE + 19)
227 #define OPTION_NO_PACK (OPTION_MD_BASE + 20)
228 #define OPTION_FDPIC (OPTION_MD_BASE + 21)
229 #define OPTION_NOPIC (OPTION_MD_BASE + 22)
230
231 struct option md_longopts[] =
232 {
233 { "mgpr-32", no_argument, NULL, OPTION_GPR_32 },
234 { "mgpr-64", no_argument, NULL, OPTION_GPR_64 },
235 { "mfpr-32", no_argument, NULL, OPTION_FPR_32 },
236 { "mfpr-64", no_argument, NULL, OPTION_FPR_64 },
237 { "mhard-float", no_argument, NULL, OPTION_FPR_64 },
238 { "msoft-float", no_argument, NULL, OPTION_SOFT_FLOAT },
239 { "mdword", no_argument, NULL, OPTION_DWORD_YES },
240 { "mno-dword", no_argument, NULL, OPTION_DWORD_NO },
241 { "mdouble", no_argument, NULL, OPTION_DOUBLE },
242 { "mno-double", no_argument, NULL, OPTION_NO_DOUBLE },
243 { "mmedia", no_argument, NULL, OPTION_MEDIA },
244 { "mno-media", no_argument, NULL, OPTION_NO_MEDIA },
245 { "mcpu", required_argument, NULL, OPTION_CPU },
246 { "mpic", no_argument, NULL, OPTION_PIC },
247 { "mPIC", no_argument, NULL, OPTION_BIGPIC },
248 { "mlibrary-pic", no_argument, NULL, OPTION_LIBPIC },
249 { "mmuladd", no_argument, NULL, OPTION_MULADD },
250 { "mno-muladd", no_argument, NULL, OPTION_NO_MULADD },
251 { "mtomcat-debug", no_argument, NULL, OPTION_TOMCAT_DEBUG },
252 { "mtomcat-stats", no_argument, NULL, OPTION_TOMCAT_STATS },
253 { "mpack", no_argument, NULL, OPTION_PACK },
254 { "mno-pack", no_argument, NULL, OPTION_NO_PACK },
255 { "mfdpic", no_argument, NULL, OPTION_FDPIC },
256 { "mnopic", no_argument, NULL, OPTION_NOPIC },
257 { NULL, no_argument, NULL, 0 },
258 };
259
260 size_t md_longopts_size = sizeof (md_longopts);
261
262 /* What value to give to bfd_set_gp_size. */
263 static int g_switch_value = 8;
264
265 int
266 md_parse_option (c, arg)
267 int c;
268 char * arg;
269 {
270 switch (c)
271 {
272 default:
273 return 0;
274
275 case 'G':
276 g_switch_value = atoi (arg);
277 if (! g_switch_value)
278 frv_flags |= EF_FRV_G0;
279 break;
280
281 case OPTION_GPR_32:
282 frv_flags = (frv_flags & ~EF_FRV_GPR_MASK) | EF_FRV_GPR_32;
283 break;
284
285 case OPTION_GPR_64:
286 frv_flags = (frv_flags & ~EF_FRV_GPR_MASK) | EF_FRV_GPR_64;
287 break;
288
289 case OPTION_FPR_32:
290 frv_flags = (frv_flags & ~EF_FRV_FPR_MASK) | EF_FRV_FPR_32;
291 break;
292
293 case OPTION_FPR_64:
294 frv_flags = (frv_flags & ~EF_FRV_FPR_MASK) | EF_FRV_FPR_64;
295 break;
296
297 case OPTION_SOFT_FLOAT:
298 frv_flags = (frv_flags & ~EF_FRV_FPR_MASK) | EF_FRV_FPR_NONE;
299 break;
300
301 case OPTION_DWORD_YES:
302 frv_flags = (frv_flags & ~EF_FRV_DWORD_MASK) | EF_FRV_DWORD_YES;
303 break;
304
305 case OPTION_DWORD_NO:
306 frv_flags = (frv_flags & ~EF_FRV_DWORD_MASK) | EF_FRV_DWORD_NO;
307 break;
308
309 case OPTION_DOUBLE:
310 frv_flags |= EF_FRV_DOUBLE;
311 break;
312
313 case OPTION_NO_DOUBLE:
314 frv_flags &= ~EF_FRV_DOUBLE;
315 break;
316
317 case OPTION_MEDIA:
318 frv_flags |= EF_FRV_MEDIA;
319 break;
320
321 case OPTION_NO_MEDIA:
322 frv_flags &= ~EF_FRV_MEDIA;
323 break;
324
325 case OPTION_MULADD:
326 frv_flags |= EF_FRV_MULADD;
327 break;
328
329 case OPTION_NO_MULADD:
330 frv_flags &= ~EF_FRV_MULADD;
331 break;
332
333 case OPTION_PACK:
334 frv_flags &= ~EF_FRV_NOPACK;
335 break;
336
337 case OPTION_NO_PACK:
338 frv_flags |= EF_FRV_NOPACK;
339 break;
340
341 case OPTION_CPU:
342 {
343 char *p;
344 int cpu_flags = EF_FRV_CPU_GENERIC;
345
346 /* Identify the processor type */
347 p = arg;
348 if (strcmp (p, "frv") == 0)
349 {
350 cpu_flags = EF_FRV_CPU_GENERIC;
351 frv_mach = bfd_mach_frv;
352 }
353
354 else if (strcmp (p, "fr500") == 0)
355 {
356 cpu_flags = EF_FRV_CPU_FR500;
357 frv_mach = bfd_mach_fr500;
358 }
359
360 else if (strcmp (p, "fr550") == 0)
361 {
362 cpu_flags = EF_FRV_CPU_FR550;
363 frv_mach = bfd_mach_fr550;
364 }
365
366 else if (strcmp (p, "fr450") == 0)
367 {
368 cpu_flags = EF_FRV_CPU_FR450;
369 frv_mach = bfd_mach_fr450;
370 }
371
372 else if (strcmp (p, "fr405") == 0)
373 {
374 cpu_flags = EF_FRV_CPU_FR405;
375 frv_mach = bfd_mach_fr400;
376 fr400_audio = TRUE;
377 }
378
379 else if (strcmp (p, "fr400") == 0)
380 {
381 cpu_flags = EF_FRV_CPU_FR400;
382 frv_mach = bfd_mach_fr400;
383 fr400_audio = FALSE;
384 }
385
386 else if (strcmp (p, "fr300") == 0)
387 {
388 cpu_flags = EF_FRV_CPU_FR300;
389 frv_mach = bfd_mach_fr300;
390 }
391
392 else if (strcmp (p, "simple") == 0)
393 {
394 cpu_flags = EF_FRV_CPU_SIMPLE;
395 frv_mach = bfd_mach_frvsimple;
396 frv_flags |= EF_FRV_NOPACK;
397 }
398
399 else if (strcmp (p, "tomcat") == 0)
400 {
401 cpu_flags = EF_FRV_CPU_TOMCAT;
402 frv_mach = bfd_mach_frvtomcat;
403 }
404
405 else
406 {
407 as_fatal ("Unknown cpu -mcpu=%s", arg);
408 return 0;
409 }
410
411 frv_flags = (frv_flags & ~EF_FRV_CPU_MASK) | cpu_flags;
412 }
413 break;
414
415 case OPTION_PIC:
416 frv_flags |= EF_FRV_PIC;
417 frv_pic_p = 1;
418 frv_pic_flag = "-fpic";
419 break;
420
421 case OPTION_BIGPIC:
422 frv_flags |= EF_FRV_BIGPIC;
423 frv_pic_p = 1;
424 frv_pic_flag = "-fPIC";
425 break;
426
427 case OPTION_LIBPIC:
428 frv_flags |= (EF_FRV_LIBPIC | EF_FRV_G0);
429 frv_pic_p = 1;
430 frv_pic_flag = "-mlibrary-pic";
431 g_switch_value = 0;
432 break;
433
434 case OPTION_FDPIC:
435 frv_flags |= EF_FRV_FDPIC;
436 frv_pic_flag = "-mfdpic";
437 break;
438
439 case OPTION_NOPIC:
440 frv_flags &= ~(EF_FRV_FDPIC | EF_FRV_PIC
441 | EF_FRV_BIGPIC | EF_FRV_LIBPIC);
442 frv_pic_flag = 0;
443 break;
444
445 case OPTION_TOMCAT_DEBUG:
446 tomcat_debug = 1;
447 break;
448
449 case OPTION_TOMCAT_STATS:
450 tomcat_stats = 1;
451 break;
452 }
453
454 return 1;
455 }
456
457 void
458 md_show_usage (stream)
459 FILE * stream;
460 {
461 fprintf (stream, _("FRV specific command line options:\n"));
462 fprintf (stream, _("-G n Data >= n bytes is in small data area\n"));
463 fprintf (stream, _("-mgpr-32 Note 32 gprs are used\n"));
464 fprintf (stream, _("-mgpr-64 Note 64 gprs are used\n"));
465 fprintf (stream, _("-mfpr-32 Note 32 fprs are used\n"));
466 fprintf (stream, _("-mfpr-64 Note 64 fprs are used\n"));
467 fprintf (stream, _("-msoft-float Note software fp is used\n"));
468 fprintf (stream, _("-mdword Note stack is aligned to a 8 byte boundary\n"));
469 fprintf (stream, _("-mno-dword Note stack is aligned to a 4 byte boundary\n"));
470 fprintf (stream, _("-mdouble Note fp double insns are used\n"));
471 fprintf (stream, _("-mmedia Note media insns are used\n"));
472 fprintf (stream, _("-mmuladd Note multiply add/subtract insns are used\n"));
473 fprintf (stream, _("-mpack Note instructions are packed\n"));
474 fprintf (stream, _("-mno-pack Do not allow instructions to be packed\n"));
475 fprintf (stream, _("-mpic Note small position independent code\n"));
476 fprintf (stream, _("-mPIC Note large position independent code\n"));
477 fprintf (stream, _("-mlibrary-pic Compile library for large position indepedent code\n"));
478 fprintf (stream, _("-mfdpic Assemble for the FDPIC ABI\n"));
479 fprintf (stream, _("-mnopic Disable -mpic, -mPIC, -mlibrary-pic and -mfdpic\n"));
480 fprintf (stream, _("-mcpu={fr500|fr550|fr400|fr405|fr450|fr300|frv|simple|tomcat}\n"));
481 fprintf (stream, _(" Record the cpu type\n"));
482 fprintf (stream, _("-mtomcat-stats Print out stats for tomcat workarounds\n"));
483 fprintf (stream, _("-mtomcat-debug Debug tomcat workarounds\n"));
484 }
485
486 \f
487 void
488 md_begin ()
489 {
490 /* Initialize the `cgen' interface. */
491
492 /* Set the machine number and endian. */
493 gas_cgen_cpu_desc = frv_cgen_cpu_open (CGEN_CPU_OPEN_MACHS, 0,
494 CGEN_CPU_OPEN_ENDIAN,
495 CGEN_ENDIAN_BIG,
496 CGEN_CPU_OPEN_END);
497 frv_cgen_init_asm (gas_cgen_cpu_desc);
498
499 /* This is a callback from cgen to gas to parse operands. */
500 cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand);
501
502 /* Set the ELF flags if desired. */
503 if (frv_flags)
504 bfd_set_private_flags (stdoutput, frv_flags);
505
506 /* Set the machine type */
507 bfd_default_set_arch_mach (stdoutput, bfd_arch_frv, frv_mach);
508
509 /* Set up gp size so we can put local common items in .sbss */
510 bfd_set_gp_size (stdoutput, g_switch_value);
511
512 frv_vliw_reset (& vliw, frv_mach, frv_flags);
513 }
514
515 bfd_boolean
516 frv_md_fdpic_enabled (void)
517 {
518 return (frv_flags & EF_FRV_FDPIC) != 0;
519 }
520
521 int chain_num = 0;
522
523 struct vliw_insn_list *frv_insert_vliw_insn PARAMS ((bfd_boolean));
524
525 struct vliw_insn_list *
526 frv_insert_vliw_insn (count)
527 bfd_boolean count;
528 {
529 struct vliw_insn_list *vliw_insn_list_entry;
530 struct vliw_chain *vliw_chain_entry;
531
532 if (current_vliw_chain == NULL)
533 {
534 vliw_chain_entry = (struct vliw_chain *) xmalloc (sizeof (struct vliw_chain));
535 vliw_chain_entry->insn_count = 0;
536 vliw_chain_entry->insn_list = NULL;
537 vliw_chain_entry->next = NULL;
538 vliw_chain_entry->num = chain_num++;
539
540 if (!vliw_chain_top)
541 vliw_chain_top = vliw_chain_entry;
542 current_vliw_chain = vliw_chain_entry;
543 if (previous_vliw_chain)
544 previous_vliw_chain->next = vliw_chain_entry;
545 }
546
547 vliw_insn_list_entry = (struct vliw_insn_list *) xmalloc (sizeof (struct vliw_insn_list));
548 vliw_insn_list_entry->type = VLIW_GENERIC_TYPE;
549 vliw_insn_list_entry->insn = NULL;
550 vliw_insn_list_entry->sym = NULL;
551 vliw_insn_list_entry->snop_frag = NULL;
552 vliw_insn_list_entry->dnop_frag = NULL;
553 vliw_insn_list_entry->next = NULL;
554
555 if (count)
556 current_vliw_chain->insn_count++;
557
558 if (current_vliw_insn)
559 current_vliw_insn->next = vliw_insn_list_entry;
560 current_vliw_insn = vliw_insn_list_entry;
561
562 if (!current_vliw_chain->insn_list)
563 current_vliw_chain->insn_list = current_vliw_insn;
564
565 return vliw_insn_list_entry;
566 }
567
568 /* Identify the following cases:
569
570 1) A VLIW insn that contains both a branch and the branch destination.
571 This requires the insertion of two vliw instructions before the
572 branch. The first consists of two nops. The second consists of
573 a single nop.
574
575 2) A single instruction VLIW insn which is the destination of a branch
576 that is in the next VLIW insn. This requires the insertion of a vliw
577 insn containing two nops before the branch.
578
579 3) A double instruction VLIW insn which contains the destination of a
580 branch that is in the next VLIW insn. This requires the insertion of
581 a VLIW insn containing a single nop before the branch.
582
583 4) A single instruction VLIW insn which contains branch destination (x),
584 followed by a single instruction VLIW insn which does not contain
585 the branch to (x), followed by a VLIW insn which does contain the branch
586 to (x). This requires the insertion of a VLIW insn containing a single
587 nop before the VLIW instruction containing the branch.
588
589 */
590 #define FRV_IS_NOP(insn) (insn.buffer[0] == FRV_NOP_PACK || insn.buffer[0] == FRV_NOP_NOPACK)
591 #define FRV_NOP_PACK 0x00880000 /* ori.p gr0,0,gr0 */
592 #define FRV_NOP_NOPACK 0x80880000 /* ori gr0,0,gr0 */
593
594 /* Check a vliw insn for an insn of type containing the sym passed in label_sym. */
595
596 static struct vliw_insn_list *frv_find_in_vliw
597 PARAMS ((enum vliw_insn_type, struct vliw_chain *, symbolS *));
598
599 static struct vliw_insn_list *
600 frv_find_in_vliw (vliw_insn_type, this_chain, label_sym)
601 enum vliw_insn_type vliw_insn_type;
602 struct vliw_chain *this_chain;
603 symbolS *label_sym;
604 {
605
606 struct vliw_insn_list *the_insn;
607
608 if (!this_chain)
609 return NULL;
610
611 for (the_insn = this_chain->insn_list; the_insn; the_insn = the_insn->next)
612 {
613 if (the_insn->type == vliw_insn_type
614 && the_insn->sym == label_sym)
615 return the_insn;
616 }
617
618 return NULL;
619 }
620
621 enum vliw_nop_type
622 {
623 /* A Vliw insn containing a single nop insn. */
624 VLIW_SINGLE_NOP,
625
626 /* A Vliw insn containing two nop insns. */
627 VLIW_DOUBLE_NOP,
628
629 /* Two vliw insns. The first containing two nop insns.
630 The second contain a single nop insn. */
631 VLIW_DOUBLE_THEN_SINGLE_NOP
632 };
633
634 static void frv_debug_tomcat PARAMS ((struct vliw_chain *));
635
636 static void
637 frv_debug_tomcat (start_chain)
638 struct vliw_chain *start_chain;
639 {
640 struct vliw_chain *this_chain;
641 struct vliw_insn_list *this_insn;
642 int i = 1;
643
644 for (this_chain = start_chain; this_chain; this_chain = this_chain->next, i++)
645 {
646 fprintf (stderr, "\nVliw Insn #%d, #insns: %d\n", i, this_chain->insn_count);
647
648 for (this_insn = this_chain->insn_list; this_insn; this_insn = this_insn->next)
649 {
650 if (this_insn->type == VLIW_LABEL_TYPE)
651 fprintf (stderr, "Label Value: %p\n", this_insn->sym);
652 else if (this_insn->type == VLIW_BRANCH_TYPE)
653 fprintf (stderr, "%s to %p\n", this_insn->insn->base->name, this_insn->sym);
654 else if (this_insn->type == VLIW_BRANCH_HAS_NOPS)
655 fprintf (stderr, "nop'd %s to %p\n", this_insn->insn->base->name, this_insn->sym);
656 else if (this_insn->type == VLIW_NOP_TYPE)
657 fprintf (stderr, "Nop\n");
658 else
659 fprintf (stderr, " %s\n", this_insn->insn->base->name);
660 }
661 }
662 }
663
664 static void frv_adjust_vliw_count PARAMS ((struct vliw_chain *));
665
666 static void
667 frv_adjust_vliw_count (this_chain)
668 struct vliw_chain *this_chain;
669 {
670 struct vliw_insn_list *this_insn;
671
672 this_chain->insn_count = 0;
673
674 for (this_insn = this_chain->insn_list;
675 this_insn;
676 this_insn = this_insn->next)
677 {
678 if (this_insn->type != VLIW_LABEL_TYPE)
679 this_chain->insn_count++;
680 }
681
682 }
683
684 /* Insert the desired nop combination in the vliw chain before insert_before_insn.
685 Rechain the vliw insn. */
686
687 static struct vliw_chain *frv_tomcat_shuffle
688 PARAMS ((enum vliw_nop_type, struct vliw_chain *, struct vliw_insn_list *));
689
690 static struct vliw_chain *
691 frv_tomcat_shuffle (this_nop_type, vliw_to_split, insert_before_insn)
692 enum vliw_nop_type this_nop_type;
693 struct vliw_chain *vliw_to_split;
694 struct vliw_insn_list *insert_before_insn;
695 {
696
697 bfd_boolean pack_prev = FALSE;
698 struct vliw_chain *return_me = NULL;
699 struct vliw_insn_list *prev_insn = NULL;
700 struct vliw_insn_list *curr_insn = vliw_to_split->insn_list;
701
702 struct vliw_chain *double_nop = (struct vliw_chain *) xmalloc (sizeof (struct vliw_chain));
703 struct vliw_chain *single_nop = (struct vliw_chain *) xmalloc (sizeof (struct vliw_chain));
704 struct vliw_chain *second_part = (struct vliw_chain *) xmalloc (sizeof (struct vliw_chain));
705 struct vliw_chain *curr_vliw = vliw_chain_top;
706 struct vliw_chain *prev_vliw = NULL;
707
708 while (curr_insn && curr_insn != insert_before_insn)
709 {
710 /* We can't set the packing bit on a label. If we have the case
711 label 1:
712 label 2:
713 label 3:
714 branch that needs nops
715 Then don't set pack bit later. */
716
717 if (curr_insn->type != VLIW_LABEL_TYPE)
718 pack_prev = TRUE;
719 prev_insn = curr_insn;
720 curr_insn = curr_insn->next;
721 }
722
723 while (curr_vliw && curr_vliw != vliw_to_split)
724 {
725 prev_vliw = curr_vliw;
726 curr_vliw = curr_vliw->next;
727 }
728
729 switch (this_nop_type)
730 {
731 case VLIW_SINGLE_NOP:
732 if (!prev_insn)
733 {
734 /* Branch is first, Insert the NOP prior to this vliw insn. */
735 if (prev_vliw)
736 prev_vliw->next = single_nop;
737 else
738 vliw_chain_top = single_nop;
739 single_nop->next = vliw_to_split;
740 vliw_to_split->insn_list->type = VLIW_BRANCH_HAS_NOPS;
741 return_me = vliw_to_split;
742 }
743 else
744 {
745 /* Set the packing bit on the previous insn. */
746 if (pack_prev)
747 {
748 char *buffer = prev_insn->address;
749 buffer[0] |= 0x80;
750 }
751 /* The branch is in the middle. Split this vliw insn into first
752 and second parts. Insert the NOP inbetween. */
753
754 second_part->insn_list = insert_before_insn;
755 second_part->insn_list->type = VLIW_BRANCH_HAS_NOPS;
756 second_part->next = vliw_to_split->next;
757 frv_adjust_vliw_count (second_part);
758
759 single_nop->next = second_part;
760
761 vliw_to_split->next = single_nop;
762 prev_insn->next = NULL;
763
764 return_me = second_part;
765 frv_adjust_vliw_count (vliw_to_split);
766 }
767 break;
768
769 case VLIW_DOUBLE_NOP:
770 if (!prev_insn)
771 {
772 /* Branch is first, Insert the NOP prior to this vliw insn. */
773 if (prev_vliw)
774 prev_vliw->next = double_nop;
775 else
776 vliw_chain_top = double_nop;
777
778 double_nop->next = vliw_to_split;
779 return_me = vliw_to_split;
780 vliw_to_split->insn_list->type = VLIW_BRANCH_HAS_NOPS;
781 }
782 else
783 {
784 /* Set the packing bit on the previous insn. */
785 if (pack_prev)
786 {
787 char *buffer = prev_insn->address;
788 buffer[0] |= 0x80;
789 }
790
791 /* The branch is in the middle. Split this vliw insn into first
792 and second parts. Insert the NOP inbetween. */
793 second_part->insn_list = insert_before_insn;
794 second_part->insn_list->type = VLIW_BRANCH_HAS_NOPS;
795 second_part->next = vliw_to_split->next;
796 frv_adjust_vliw_count (second_part);
797
798 double_nop->next = second_part;
799
800 vliw_to_split->next = single_nop;
801 prev_insn->next = NULL;
802 frv_adjust_vliw_count (vliw_to_split);
803
804 return_me = second_part;
805 }
806 break;
807
808 case VLIW_DOUBLE_THEN_SINGLE_NOP:
809 double_nop->next = single_nop;
810 double_nop->insn_count = 2;
811 double_nop->insn_list = &double_nop_insn;
812 single_nop->insn_count = 1;
813 single_nop->insn_list = &single_nop_insn;
814
815 if (!prev_insn)
816 {
817 /* The branch is the first insn in this vliw. Don't split the vliw. Insert
818 the nops prior to this vliw. */
819 if (prev_vliw)
820 prev_vliw->next = double_nop;
821 else
822 vliw_chain_top = double_nop;
823
824 single_nop->next = vliw_to_split;
825 return_me = vliw_to_split;
826 vliw_to_split->insn_list->type = VLIW_BRANCH_HAS_NOPS;
827 }
828 else
829 {
830 /* Set the packing bit on the previous insn. */
831 if (pack_prev)
832 {
833 char *buffer = prev_insn->address;
834 buffer[0] |= 0x80;
835 }
836
837 /* The branch is in the middle of this vliw insn. Split into first and
838 second parts. Insert the nop vliws in between. */
839 second_part->insn_list = insert_before_insn;
840 second_part->insn_list->type = VLIW_BRANCH_HAS_NOPS;
841 second_part->next = vliw_to_split->next;
842 frv_adjust_vliw_count (second_part);
843
844 single_nop->next = second_part;
845
846 vliw_to_split->next = double_nop;
847 prev_insn->next = NULL;
848 frv_adjust_vliw_count (vliw_to_split);
849
850 return_me = second_part;
851 }
852 break;
853 }
854
855 return return_me;
856 }
857
858 static void frv_tomcat_analyze_vliw_chains PARAMS ((void));
859
860 static void
861 frv_tomcat_analyze_vliw_chains ()
862 {
863 struct vliw_chain *vliw1 = NULL;
864 struct vliw_chain *vliw2 = NULL;
865 struct vliw_chain *vliw3 = NULL;
866
867 struct vliw_insn_list *this_insn = NULL;
868 struct vliw_insn_list *temp_insn = NULL;
869
870 /* We potentially need to look at three VLIW insns to determine if the
871 workaround is required. Set them up. Ignore existing nops during analysis. */
872
873 #define FRV_SET_VLIW_WINDOW(VLIW1, VLIW2, VLIW3) \
874 if (VLIW1 && VLIW1->next) \
875 VLIW2 = VLIW1->next; \
876 else \
877 VLIW2 = NULL; \
878 if (VLIW2 && VLIW2->next) \
879 VLIW3 = VLIW2->next; \
880 else \
881 VLIW3 = NULL
882
883 vliw1 = vliw_chain_top;
884
885 workaround_top:
886
887 FRV_SET_VLIW_WINDOW (vliw1, vliw2, vliw3);
888
889 if (!vliw1)
890 return;
891
892 if (vliw1->insn_count == 1)
893 {
894 /* check vliw1 for a label. */
895 if (vliw1->insn_list->type == VLIW_LABEL_TYPE)
896 {
897 temp_insn = frv_find_in_vliw (VLIW_BRANCH_TYPE, vliw2, vliw1->insn_list->sym);
898 if (temp_insn)
899 {
900 vliw1 = frv_tomcat_shuffle (VLIW_DOUBLE_NOP, vliw2, vliw1->insn_list);
901 temp_insn->dnop_frag->fr_subtype = NOP_KEEP;
902 vliw1 = vliw1->next;
903 if (tomcat_stats)
904 tomcat_doubles++;
905 goto workaround_top;
906 }
907 else if (vliw2
908 && vliw2->insn_count == 1
909 && (temp_insn = frv_find_in_vliw (VLIW_BRANCH_TYPE, vliw3, vliw1->insn_list->sym)) != NULL)
910 {
911 temp_insn->snop_frag->fr_subtype = NOP_KEEP;
912 vliw1 = frv_tomcat_shuffle (VLIW_SINGLE_NOP, vliw3, vliw3->insn_list);
913 if (tomcat_stats)
914 tomcat_singles++;
915 goto workaround_top;
916 }
917 }
918 }
919
920 if (vliw1->insn_count == 2)
921 {
922 struct vliw_insn_list *this_insn;
923
924 /* check vliw1 for a label. */
925 for (this_insn = vliw1->insn_list; this_insn; this_insn = this_insn->next)
926 {
927 if (this_insn->type == VLIW_LABEL_TYPE)
928 {
929 if ((temp_insn = frv_find_in_vliw (VLIW_BRANCH_TYPE, vliw2, this_insn->sym)) != NULL)
930 {
931 temp_insn->snop_frag->fr_subtype = NOP_KEEP;
932 vliw1 = frv_tomcat_shuffle (VLIW_SINGLE_NOP, vliw2, this_insn);
933 if (tomcat_stats)
934 tomcat_singles++;
935 }
936 else
937 vliw1 = vliw1->next;
938 goto workaround_top;
939 }
940 }
941 }
942 /* Examine each insn in this VLIW. Look for the workaround criteria. */
943 for (this_insn = vliw1->insn_list; this_insn; this_insn = this_insn->next)
944 {
945 /* Don't look at labels or nops. */
946 while (this_insn
947 && (this_insn->type == VLIW_LABEL_TYPE
948 || this_insn->type == VLIW_NOP_TYPE
949 || this_insn->type == VLIW_BRANCH_HAS_NOPS))
950 this_insn = this_insn->next;
951
952 if (!this_insn)
953 {
954 vliw1 = vliw2;
955 goto workaround_top;
956 }
957
958 if (frv_is_branch_insn (this_insn->insn))
959 {
960 if ((temp_insn = frv_find_in_vliw (VLIW_LABEL_TYPE, vliw1, this_insn->sym)) != NULL)
961 {
962 /* Insert [nop/nop] [nop] before branch. */
963 this_insn->snop_frag->fr_subtype = NOP_KEEP;
964 this_insn->dnop_frag->fr_subtype = NOP_KEEP;
965 vliw1 = frv_tomcat_shuffle (VLIW_DOUBLE_THEN_SINGLE_NOP, vliw1, this_insn);
966 goto workaround_top;
967 }
968 }
969
970
971 }
972 /* This vliw insn checks out okay. Take a look at the next one. */
973 vliw1 = vliw1->next;
974 goto workaround_top;
975 }
976
977 void
978 frv_tomcat_workaround ()
979 {
980 if (frv_mach != bfd_mach_frvtomcat)
981 return;
982
983 if (tomcat_debug)
984 frv_debug_tomcat (vliw_chain_top);
985
986 frv_tomcat_analyze_vliw_chains ();
987
988 if (tomcat_stats)
989 {
990 fprintf (stderr, "Inserted %d Single Nops\n", tomcat_singles);
991 fprintf (stderr, "Inserted %d Double Nops\n", tomcat_doubles);
992 }
993 }
994
995 static int
996 fr550_check_insn_acc_range (frv_insn *insn, int low, int hi)
997 {
998 int acc;
999 switch (CGEN_INSN_NUM (insn->insn))
1000 {
1001 case FRV_INSN_MADDACCS:
1002 case FRV_INSN_MSUBACCS:
1003 case FRV_INSN_MDADDACCS:
1004 case FRV_INSN_MDSUBACCS:
1005 case FRV_INSN_MASACCS:
1006 case FRV_INSN_MDASACCS:
1007 acc = insn->fields.f_ACC40Si;
1008 if (acc < low || acc > hi)
1009 return 1; /* out of range */
1010 acc = insn->fields.f_ACC40Sk;
1011 if (acc < low || acc > hi)
1012 return 1; /* out of range */
1013 break;
1014 case FRV_INSN_MMULHS:
1015 case FRV_INSN_MMULHU:
1016 case FRV_INSN_MMULXHS:
1017 case FRV_INSN_MMULXHU:
1018 case FRV_INSN_CMMULHS:
1019 case FRV_INSN_CMMULHU:
1020 case FRV_INSN_MQMULHS:
1021 case FRV_INSN_MQMULHU:
1022 case FRV_INSN_MQMULXHS:
1023 case FRV_INSN_MQMULXHU:
1024 case FRV_INSN_CMQMULHS:
1025 case FRV_INSN_CMQMULHU:
1026 case FRV_INSN_MMACHS:
1027 case FRV_INSN_MMRDHS:
1028 case FRV_INSN_CMMACHS:
1029 case FRV_INSN_MQMACHS:
1030 case FRV_INSN_CMQMACHS:
1031 case FRV_INSN_MQXMACHS:
1032 case FRV_INSN_MQXMACXHS:
1033 case FRV_INSN_MQMACXHS:
1034 case FRV_INSN_MCPXRS:
1035 case FRV_INSN_MCPXIS:
1036 case FRV_INSN_CMCPXRS:
1037 case FRV_INSN_CMCPXIS:
1038 case FRV_INSN_MQCPXRS:
1039 case FRV_INSN_MQCPXIS:
1040 acc = insn->fields.f_ACC40Sk;
1041 if (acc < low || acc > hi)
1042 return 1; /* out of range */
1043 break;
1044 case FRV_INSN_MMACHU:
1045 case FRV_INSN_MMRDHU:
1046 case FRV_INSN_CMMACHU:
1047 case FRV_INSN_MQMACHU:
1048 case FRV_INSN_CMQMACHU:
1049 case FRV_INSN_MCPXRU:
1050 case FRV_INSN_MCPXIU:
1051 case FRV_INSN_CMCPXRU:
1052 case FRV_INSN_CMCPXIU:
1053 case FRV_INSN_MQCPXRU:
1054 case FRV_INSN_MQCPXIU:
1055 acc = insn->fields.f_ACC40Uk;
1056 if (acc < low || acc > hi)
1057 return 1; /* out of range */
1058 break;
1059 default:
1060 break;
1061 }
1062 return 0; /* all is ok */
1063 }
1064
1065 static int
1066 fr550_check_acc_range (FRV_VLIW *vliw, frv_insn *insn)
1067 {
1068 switch ((*vliw->current_vliw)[vliw->next_slot - 1])
1069 {
1070 case UNIT_FM0:
1071 case UNIT_FM2:
1072 return fr550_check_insn_acc_range (insn, 0, 3);
1073 case UNIT_FM1:
1074 case UNIT_FM3:
1075 return fr550_check_insn_acc_range (insn, 4, 7);
1076 default:
1077 break;
1078 }
1079 return 0; /* all is ok */
1080 }
1081
1082 /* Return true if the target implements instruction INSN. */
1083
1084 static bfd_boolean
1085 target_implements_insn_p (const CGEN_INSN *insn)
1086 {
1087 switch (frv_mach)
1088 {
1089 default:
1090 /* bfd_mach_frv or generic. */
1091 return TRUE;
1092
1093 case bfd_mach_fr300:
1094 case bfd_mach_frvsimple:
1095 return CGEN_INSN_MACH_HAS_P (insn, MACH_SIMPLE);
1096
1097 case bfd_mach_fr400:
1098 return ((fr400_audio || !CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_AUDIO))
1099 && CGEN_INSN_MACH_HAS_P (insn, MACH_FR400));
1100
1101 case bfd_mach_fr450:
1102 return CGEN_INSN_MACH_HAS_P (insn, MACH_FR450);
1103
1104 case bfd_mach_fr500:
1105 return CGEN_INSN_MACH_HAS_P (insn, MACH_FR500);
1106
1107 case bfd_mach_fr550:
1108 return CGEN_INSN_MACH_HAS_P (insn, MACH_FR550);
1109 }
1110 }
1111
1112 void
1113 md_assemble (str)
1114 char * str;
1115 {
1116 frv_insn insn;
1117 char *errmsg;
1118 int packing_constraint;
1119 finished_insnS finished_insn;
1120 fragS *double_nop_frag = NULL;
1121 fragS *single_nop_frag = NULL;
1122 struct vliw_insn_list *vliw_insn_list_entry = NULL;
1123
1124 /* Initialize GAS's cgen interface for a new instruction. */
1125 gas_cgen_init_parse ();
1126
1127 memset (&insn, 0, sizeof (insn));
1128
1129 insn.insn = frv_cgen_assemble_insn
1130 (gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, &errmsg);
1131
1132 if (!insn.insn)
1133 {
1134 as_bad (errmsg);
1135 return;
1136 }
1137
1138 /* If the cpu is tomcat, then we need to insert nops to workaround
1139 hardware limitations. We need to keep track of each vliw unit
1140 and examine the length of the unit and the individual insns
1141 within the unit to determine the number and location of the
1142 required nops. */
1143 if (frv_mach == bfd_mach_frvtomcat)
1144 {
1145 /* If we've just finished a VLIW insn OR this is a branch,
1146 then start up a new frag. Fill it with nops. We will get rid
1147 of those that are not required after we've seen all of the
1148 instructions but before we start resolving fixups. */
1149 if ( !FRV_IS_NOP (insn)
1150 && (frv_is_branch_insn (insn.insn) || insn.fields.f_pack))
1151 {
1152 char *buffer;
1153
1154 frag_wane (frag_now);
1155 frag_new (0);
1156 double_nop_frag = frag_now;
1157 buffer = frag_var (rs_machine_dependent, 8, 8, NOP_DELETE, NULL, 0, 0);
1158 md_number_to_chars (buffer, FRV_NOP_PACK, 4);
1159 md_number_to_chars (buffer+4, FRV_NOP_NOPACK, 4);
1160
1161 frag_wane (frag_now);
1162 frag_new (0);
1163 single_nop_frag = frag_now;
1164 buffer = frag_var (rs_machine_dependent, 4, 4, NOP_DELETE, NULL, 0, 0);
1165 md_number_to_chars (buffer, FRV_NOP_NOPACK, 4);
1166 }
1167
1168 vliw_insn_list_entry = frv_insert_vliw_insn (DO_COUNT);
1169 vliw_insn_list_entry->insn = insn.insn;
1170 if (frv_is_branch_insn (insn.insn))
1171 vliw_insn_list_entry->type = VLIW_BRANCH_TYPE;
1172
1173 if ( !FRV_IS_NOP (insn)
1174 && (frv_is_branch_insn (insn.insn) || insn.fields.f_pack))
1175 {
1176 vliw_insn_list_entry->snop_frag = single_nop_frag;
1177 vliw_insn_list_entry->dnop_frag = double_nop_frag;
1178 }
1179 }
1180
1181 /* Make sure that this insn does not violate the VLIW packing constraints. */
1182 /* -mno-pack disallows any packing whatsoever. */
1183 if (frv_flags & EF_FRV_NOPACK)
1184 {
1185 if (! insn.fields.f_pack)
1186 {
1187 as_bad (_("VLIW packing used for -mno-pack"));
1188 return;
1189 }
1190 }
1191 /* -mcpu=FRV is an idealized FR-V implementation that supports all of the
1192 instructions, don't do vliw checking. */
1193 else if (frv_mach != bfd_mach_frv)
1194 {
1195 if (!target_implements_insn_p (insn.insn))
1196 {
1197 as_bad (_("Instruction not supported by this architecture"));
1198 return;
1199 }
1200 packing_constraint = frv_vliw_add_insn (& vliw, insn.insn);
1201 if (frv_mach == bfd_mach_fr550 && ! packing_constraint)
1202 packing_constraint = fr550_check_acc_range (& vliw, & insn);
1203 if (insn.fields.f_pack)
1204 frv_vliw_reset (& vliw, frv_mach, frv_flags);
1205 if (packing_constraint)
1206 {
1207 as_bad (_("VLIW packing constraint violation"));
1208 return;
1209 }
1210 }
1211
1212 /* Doesn't really matter what we pass for RELAX_P here. */
1213 gas_cgen_finish_insn (insn.insn, insn.buffer,
1214 CGEN_FIELDS_BITSIZE (& insn.fields), 1, &finished_insn);
1215
1216
1217 /* If the cpu is tomcat, then we need to insert nops to workaround
1218 hardware limitations. We need to keep track of each vliw unit
1219 and examine the length of the unit and the individual insns
1220 within the unit to determine the number and location of the
1221 required nops. */
1222 if (frv_mach == bfd_mach_frvtomcat)
1223 {
1224 if (vliw_insn_list_entry)
1225 vliw_insn_list_entry->address = finished_insn.addr;
1226 else
1227 abort();
1228
1229 if (insn.fields.f_pack)
1230 {
1231 /* We've completed a VLIW insn. */
1232 previous_vliw_chain = current_vliw_chain;
1233 current_vliw_chain = NULL;
1234 current_vliw_insn = NULL;
1235 }
1236 }
1237 }
1238
1239 /* The syntax in the manual says constants begin with '#'.
1240 We just ignore it. */
1241
1242 void
1243 md_operand (expressionP)
1244 expressionS * expressionP;
1245 {
1246 if (* input_line_pointer == '#')
1247 {
1248 input_line_pointer ++;
1249 expression (expressionP);
1250 }
1251 }
1252
1253 valueT
1254 md_section_align (segment, size)
1255 segT segment;
1256 valueT size;
1257 {
1258 int align = bfd_get_section_alignment (stdoutput, segment);
1259 return ((size + (1 << align) - 1) & (-1 << align));
1260 }
1261
1262 symbolS *
1263 md_undefined_symbol (name)
1264 char * name ATTRIBUTE_UNUSED;
1265 {
1266 return 0;
1267 }
1268 \f
1269 /* Interface to relax_segment. */
1270
1271 /* FIXME: Build table by hand, get it working, then machine generate. */
1272 const relax_typeS md_relax_table[] =
1273 {
1274 {1, 1, 0, 0},
1275 {511 - 2 - 2, -512 - 2 + 2, 0, 2 },
1276 {0x2000000 - 1 - 2, -0x2000000 - 2, 2, 0 },
1277 {0x2000000 - 1 - 2, -0x2000000 - 2, 4, 0 }
1278 };
1279
1280 long
1281 frv_relax_frag (fragP, stretch)
1282 fragS *fragP ATTRIBUTE_UNUSED;
1283 long stretch ATTRIBUTE_UNUSED;
1284 {
1285 return 0;
1286 }
1287
1288 /* Return an initial guess of the length by which a fragment must grow to
1289 hold a branch to reach its destination.
1290 Also updates fr_type/fr_subtype as necessary.
1291
1292 Called just before doing relaxation.
1293 Any symbol that is now undefined will not become defined.
1294 The guess for fr_var is ACTUALLY the growth beyond fr_fix.
1295 Whatever we do to grow fr_fix or fr_var contributes to our returned value.
1296 Although it may not be explicit in the frag, pretend fr_var starts with a
1297 0 value. */
1298
1299 int
1300 md_estimate_size_before_relax (fragP, segment)
1301 fragS * fragP;
1302 segT segment ATTRIBUTE_UNUSED;
1303 {
1304 switch (fragP->fr_subtype)
1305 {
1306 case NOP_KEEP:
1307 return fragP->fr_var;
1308
1309 default:
1310 case NOP_DELETE:
1311 return 0;
1312 }
1313 }
1314
1315 /* *fragP has been relaxed to its final size, and now needs to have
1316 the bytes inside it modified to conform to the new size.
1317
1318 Called after relaxation is finished.
1319 fragP->fr_type == rs_machine_dependent.
1320 fragP->fr_subtype is the subtype of what the address relaxed to. */
1321
1322 void
1323 md_convert_frag (abfd, sec, fragP)
1324 bfd * abfd ATTRIBUTE_UNUSED;
1325 segT sec ATTRIBUTE_UNUSED;
1326 fragS * fragP;
1327 {
1328 switch (fragP->fr_subtype)
1329 {
1330 default:
1331 case NOP_DELETE:
1332 return;
1333
1334 case NOP_KEEP:
1335 fragP->fr_fix = fragP->fr_var;
1336 fragP->fr_var = 0;
1337 return;
1338 }
1339 }
1340 \f
1341 /* Functions concerning relocs. */
1342
1343 /* The location from which a PC relative jump should be calculated,
1344 given a PC relative reloc. */
1345
1346 long
1347 md_pcrel_from_section (fixP, sec)
1348 fixS * fixP;
1349 segT sec;
1350 {
1351 if (TC_FORCE_RELOCATION (fixP)
1352 || (fixP->fx_addsy != (symbolS *) NULL
1353 && S_GET_SEGMENT (fixP->fx_addsy) != sec))
1354 {
1355 /* If we can't adjust this relocation, or if it references a
1356 local symbol in a different section (which
1357 TC_FORCE_RELOCATION can't check), let the linker figure it
1358 out. */
1359 return 0;
1360 }
1361
1362 return (fixP->fx_frag->fr_address + fixP->fx_where) & ~1;
1363 }
1364
1365 /* Return the bfd reloc type for OPERAND of INSN at fixup FIXP.
1366 Returns BFD_RELOC_NONE if no reloc type can be found.
1367 *FIXP may be modified if desired. */
1368
1369 bfd_reloc_code_real_type
1370 md_cgen_lookup_reloc (insn, operand, fixP)
1371 const CGEN_INSN * insn ATTRIBUTE_UNUSED;
1372 const CGEN_OPERAND * operand;
1373 fixS * fixP;
1374 {
1375 switch (operand->type)
1376 {
1377 case FRV_OPERAND_LABEL16:
1378 fixP->fx_pcrel = TRUE;
1379 return BFD_RELOC_FRV_LABEL16;
1380
1381 case FRV_OPERAND_LABEL24:
1382 fixP->fx_pcrel = TRUE;
1383
1384 if (fixP->fx_cgen.opinfo != 0)
1385 return fixP->fx_cgen.opinfo;
1386
1387 return BFD_RELOC_FRV_LABEL24;
1388
1389 case FRV_OPERAND_UHI16:
1390 case FRV_OPERAND_ULO16:
1391 case FRV_OPERAND_SLO16:
1392 case FRV_OPERAND_CALLANN:
1393 case FRV_OPERAND_LDANN:
1394 case FRV_OPERAND_LDDANN:
1395 /* The relocation type should be recorded in opinfo */
1396 if (fixP->fx_cgen.opinfo != 0)
1397 return fixP->fx_cgen.opinfo;
1398 break;
1399
1400 case FRV_OPERAND_D12:
1401 case FRV_OPERAND_S12:
1402 if (fixP->fx_cgen.opinfo != 0)
1403 return fixP->fx_cgen.opinfo;
1404
1405 return BFD_RELOC_FRV_GPREL12;
1406
1407 case FRV_OPERAND_U12:
1408 return BFD_RELOC_FRV_GPRELU12;
1409
1410 default:
1411 break;
1412 }
1413 return BFD_RELOC_NONE;
1414 }
1415
1416
1417 /* See whether we need to force a relocation into the output file.
1418 This is used to force out switch and PC relative relocations when
1419 relaxing. */
1420
1421 int
1422 frv_force_relocation (fix)
1423 fixS * fix;
1424 {
1425 switch (fix->fx_r_type < BFD_RELOC_UNUSED
1426 ? (int) fix->fx_r_type
1427 : fix->fx_cgen.opinfo)
1428 {
1429 case BFD_RELOC_FRV_GPREL12:
1430 case BFD_RELOC_FRV_GPRELU12:
1431 case BFD_RELOC_FRV_GPREL32:
1432 case BFD_RELOC_FRV_GPRELHI:
1433 case BFD_RELOC_FRV_GPRELLO:
1434 case BFD_RELOC_FRV_GOT12:
1435 case BFD_RELOC_FRV_GOTHI:
1436 case BFD_RELOC_FRV_GOTLO:
1437 case BFD_RELOC_FRV_FUNCDESC_VALUE:
1438 case BFD_RELOC_FRV_FUNCDESC_GOTOFF12:
1439 case BFD_RELOC_FRV_FUNCDESC_GOTOFFHI:
1440 case BFD_RELOC_FRV_FUNCDESC_GOTOFFLO:
1441 case BFD_RELOC_FRV_GOTOFF12:
1442 case BFD_RELOC_FRV_GOTOFFHI:
1443 case BFD_RELOC_FRV_GOTOFFLO:
1444 case BFD_RELOC_FRV_GETTLSOFF:
1445 case BFD_RELOC_FRV_TLSDESC_VALUE:
1446 case BFD_RELOC_FRV_GOTTLSDESC12:
1447 case BFD_RELOC_FRV_GOTTLSDESCHI:
1448 case BFD_RELOC_FRV_GOTTLSDESCLO:
1449 case BFD_RELOC_FRV_TLSMOFF12:
1450 case BFD_RELOC_FRV_TLSMOFFHI:
1451 case BFD_RELOC_FRV_TLSMOFFLO:
1452 case BFD_RELOC_FRV_GOTTLSOFF12:
1453 case BFD_RELOC_FRV_GOTTLSOFFHI:
1454 case BFD_RELOC_FRV_GOTTLSOFFLO:
1455 case BFD_RELOC_FRV_TLSOFF:
1456 case BFD_RELOC_FRV_TLSDESC_RELAX:
1457 case BFD_RELOC_FRV_GETTLSOFF_RELAX:
1458 case BFD_RELOC_FRV_TLSOFF_RELAX:
1459 return 1;
1460
1461 default:
1462 break;
1463 }
1464
1465 return generic_force_reloc (fix);
1466 }
1467
1468 /* Apply a fixup that could be resolved within the assembler. */
1469
1470 void
1471 md_apply_fix (fixP, valP, seg)
1472 fixS * fixP;
1473 valueT * valP;
1474 segT seg;
1475 {
1476 if (fixP->fx_addsy == 0)
1477 switch (fixP->fx_cgen.opinfo)
1478 {
1479 case BFD_RELOC_FRV_HI16:
1480 *valP >>= 16;
1481 /* Fall through. */
1482 case BFD_RELOC_FRV_LO16:
1483 *valP &= 0xffff;
1484 break;
1485
1486 /* We need relocations for these, even if their symbols reduce
1487 to constants. */
1488 case BFD_RELOC_FRV_GPREL12:
1489 case BFD_RELOC_FRV_GPRELU12:
1490 case BFD_RELOC_FRV_GPREL32:
1491 case BFD_RELOC_FRV_GPRELHI:
1492 case BFD_RELOC_FRV_GPRELLO:
1493 case BFD_RELOC_FRV_GOT12:
1494 case BFD_RELOC_FRV_GOTHI:
1495 case BFD_RELOC_FRV_GOTLO:
1496 case BFD_RELOC_FRV_FUNCDESC_VALUE:
1497 case BFD_RELOC_FRV_FUNCDESC_GOTOFF12:
1498 case BFD_RELOC_FRV_FUNCDESC_GOTOFFHI:
1499 case BFD_RELOC_FRV_FUNCDESC_GOTOFFLO:
1500 case BFD_RELOC_FRV_GOTOFF12:
1501 case BFD_RELOC_FRV_GOTOFFHI:
1502 case BFD_RELOC_FRV_GOTOFFLO:
1503 case BFD_RELOC_FRV_GETTLSOFF:
1504 case BFD_RELOC_FRV_TLSDESC_VALUE:
1505 case BFD_RELOC_FRV_GOTTLSDESC12:
1506 case BFD_RELOC_FRV_GOTTLSDESCHI:
1507 case BFD_RELOC_FRV_GOTTLSDESCLO:
1508 case BFD_RELOC_FRV_TLSMOFF12:
1509 case BFD_RELOC_FRV_TLSMOFFHI:
1510 case BFD_RELOC_FRV_TLSMOFFLO:
1511 case BFD_RELOC_FRV_GOTTLSOFF12:
1512 case BFD_RELOC_FRV_GOTTLSOFFHI:
1513 case BFD_RELOC_FRV_GOTTLSOFFLO:
1514 case BFD_RELOC_FRV_TLSOFF:
1515 case BFD_RELOC_FRV_TLSDESC_RELAX:
1516 case BFD_RELOC_FRV_GETTLSOFF_RELAX:
1517 case BFD_RELOC_FRV_TLSOFF_RELAX:
1518 fixP->fx_addsy = expr_build_uconstant (0);
1519 break;
1520 }
1521 else
1522 switch (fixP->fx_cgen.opinfo)
1523 {
1524 case BFD_RELOC_FRV_GETTLSOFF:
1525 case BFD_RELOC_FRV_TLSDESC_VALUE:
1526 case BFD_RELOC_FRV_GOTTLSDESC12:
1527 case BFD_RELOC_FRV_GOTTLSDESCHI:
1528 case BFD_RELOC_FRV_GOTTLSDESCLO:
1529 case BFD_RELOC_FRV_TLSMOFF12:
1530 case BFD_RELOC_FRV_TLSMOFFHI:
1531 case BFD_RELOC_FRV_TLSMOFFLO:
1532 case BFD_RELOC_FRV_GOTTLSOFF12:
1533 case BFD_RELOC_FRV_GOTTLSOFFHI:
1534 case BFD_RELOC_FRV_GOTTLSOFFLO:
1535 case BFD_RELOC_FRV_TLSOFF:
1536 case BFD_RELOC_FRV_TLSDESC_RELAX:
1537 case BFD_RELOC_FRV_GETTLSOFF_RELAX:
1538 case BFD_RELOC_FRV_TLSOFF_RELAX:
1539 /* Mark TLS symbols as such. */
1540 if (S_GET_SEGMENT (fixP->fx_addsy) != absolute_section)
1541 S_SET_THREAD_LOCAL (fixP->fx_addsy);
1542 break;
1543 }
1544
1545 gas_cgen_md_apply_fix (fixP, valP, seg);
1546 return;
1547 }
1548
1549 \f
1550 /* Write a value out to the object file, using the appropriate endianness. */
1551
1552 void
1553 frv_md_number_to_chars (buf, val, n)
1554 char * buf;
1555 valueT val;
1556 int n;
1557 {
1558 number_to_chars_bigendian (buf, val, n);
1559 }
1560
1561 /* Turn a string in input_line_pointer into a floating point constant of type
1562 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
1563 emitted is stored in *sizeP . An error message is returned, or NULL on OK.
1564 */
1565
1566 /* Equal to MAX_PRECISION in atof-ieee.c */
1567 #define MAX_LITTLENUMS 6
1568
1569 char *
1570 md_atof (type, litP, sizeP)
1571 char type;
1572 char * litP;
1573 int * sizeP;
1574 {
1575 int i;
1576 int prec;
1577 LITTLENUM_TYPE words [MAX_LITTLENUMS];
1578 char * t;
1579
1580 switch (type)
1581 {
1582 case 'f':
1583 case 'F':
1584 case 's':
1585 case 'S':
1586 prec = 2;
1587 break;
1588
1589 case 'd':
1590 case 'D':
1591 case 'r':
1592 case 'R':
1593 prec = 4;
1594 break;
1595
1596 /* FIXME: Some targets allow other format chars for bigger sizes here. */
1597
1598 default:
1599 * sizeP = 0;
1600 return _("Bad call to md_atof()");
1601 }
1602
1603 t = atof_ieee (input_line_pointer, type, words);
1604 if (t)
1605 input_line_pointer = t;
1606 * sizeP = prec * sizeof (LITTLENUM_TYPE);
1607
1608 for (i = 0; i < prec; i++)
1609 {
1610 md_number_to_chars (litP, (valueT) words[i],
1611 sizeof (LITTLENUM_TYPE));
1612 litP += sizeof (LITTLENUM_TYPE);
1613 }
1614
1615 return 0;
1616 }
1617
1618 bfd_boolean
1619 frv_fix_adjustable (fixP)
1620 fixS * fixP;
1621 {
1622 bfd_reloc_code_real_type reloc_type;
1623
1624 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
1625 {
1626 const CGEN_INSN *insn = NULL;
1627 int opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
1628 const CGEN_OPERAND *operand = cgen_operand_lookup_by_num(gas_cgen_cpu_desc, opindex);
1629 reloc_type = md_cgen_lookup_reloc (insn, operand, fixP);
1630 }
1631 else
1632 reloc_type = fixP->fx_r_type;
1633
1634 /* We need the symbol name for the VTABLE entries */
1635 if ( reloc_type == BFD_RELOC_VTABLE_INHERIT
1636 || reloc_type == BFD_RELOC_VTABLE_ENTRY
1637 || reloc_type == BFD_RELOC_FRV_GPREL12
1638 || reloc_type == BFD_RELOC_FRV_GPRELU12)
1639 return 0;
1640
1641 return 1;
1642 }
1643
1644 /* Allow user to set flags bits. */
1645 void
1646 frv_set_flags (arg)
1647 int arg ATTRIBUTE_UNUSED;
1648 {
1649 flagword new_flags = get_absolute_expression ();
1650 flagword new_mask = ~ (flagword)0;
1651
1652 frv_user_set_flags_p = 1;
1653 if (*input_line_pointer == ',')
1654 {
1655 ++input_line_pointer;
1656 new_mask = get_absolute_expression ();
1657 }
1658
1659 frv_flags = (frv_flags & ~new_mask) | (new_flags & new_mask);
1660 bfd_set_private_flags (stdoutput, frv_flags);
1661 }
1662
1663 /* Frv specific function to handle 4 byte initializations for pointers that are
1664 considered 'safe' for use with pic support. Until frv_frob_file{,_section}
1665 is run, we encode it a BFD_RELOC_CTOR, and it is turned back into a normal
1666 BFD_RELOC_32 at that time. */
1667
1668 void
1669 frv_pic_ptr (nbytes)
1670 int nbytes;
1671 {
1672 expressionS exp;
1673 char *p;
1674
1675 if (nbytes != 4)
1676 abort ();
1677
1678 #ifdef md_flush_pending_output
1679 md_flush_pending_output ();
1680 #endif
1681
1682 if (is_it_end_of_statement ())
1683 {
1684 demand_empty_rest_of_line ();
1685 return;
1686 }
1687
1688 #ifdef md_cons_align
1689 md_cons_align (nbytes);
1690 #endif
1691
1692 do
1693 {
1694 bfd_reloc_code_real_type reloc_type = BFD_RELOC_CTOR;
1695
1696 if (strncasecmp (input_line_pointer, "funcdesc(", 9) == 0)
1697 {
1698 input_line_pointer += 9;
1699 expression (&exp);
1700 if (*input_line_pointer == ')')
1701 input_line_pointer++;
1702 else
1703 as_bad ("missing ')'");
1704 reloc_type = BFD_RELOC_FRV_FUNCDESC;
1705 }
1706 else if (strncasecmp (input_line_pointer, "tlsmoff(", 8) == 0)
1707 {
1708 input_line_pointer += 8;
1709 expression (&exp);
1710 if (*input_line_pointer == ')')
1711 input_line_pointer++;
1712 else
1713 as_bad ("missing ')'");
1714 reloc_type = BFD_RELOC_FRV_TLSMOFF;
1715 }
1716 else
1717 expression (&exp);
1718
1719 p = frag_more (4);
1720 memset (p, 0, 4);
1721 fix_new_exp (frag_now, p - frag_now->fr_literal, 4, &exp, 0,
1722 reloc_type);
1723 }
1724 while (*input_line_pointer++ == ',');
1725
1726 input_line_pointer--; /* Put terminator back into stream. */
1727 demand_empty_rest_of_line ();
1728 }
1729
1730 \f
1731
1732 #ifdef DEBUG
1733 #define DPRINTF1(A) fprintf (stderr, A)
1734 #define DPRINTF2(A,B) fprintf (stderr, A, B)
1735 #define DPRINTF3(A,B,C) fprintf (stderr, A, B, C)
1736
1737 #else
1738 #define DPRINTF1(A)
1739 #define DPRINTF2(A,B)
1740 #define DPRINTF3(A,B,C)
1741 #endif
1742
1743 /* Go through a the sections looking for relocations that are problematical for
1744 pic. If not pic, just note that this object can't be linked with pic. If
1745 it is pic, see if it needs to be marked so that it will be fixed up, or if
1746 not possible, issue an error. */
1747
1748 static void
1749 frv_frob_file_section (abfd, sec, ptr)
1750 bfd *abfd;
1751 asection *sec;
1752 PTR ptr ATTRIBUTE_UNUSED;
1753 {
1754 segment_info_type *seginfo = seg_info (sec);
1755 fixS *fixp;
1756 CGEN_CPU_DESC cd = gas_cgen_cpu_desc;
1757 flagword flags = bfd_get_section_flags (abfd, sec);
1758
1759 /* Skip relocations in known sections (.ctors, .dtors, and .gcc_except_table)
1760 since we can fix those up by hand. */
1761 int known_section_p = (sec->name
1762 && sec->name[0] == '.'
1763 && ((sec->name[1] == 'c'
1764 && strcmp (sec->name, ".ctor") == 0)
1765 || (sec->name[1] == 'd'
1766 && strcmp (sec->name, ".dtor") == 0)
1767 || (sec->name[1] == 'g'
1768 && strcmp (sec->name, ".gcc_except_table") == 0)));
1769
1770 DPRINTF3 ("\nFrv section %s%s\n", sec->name, (known_section_p) ? ", known section" : "");
1771 if ((flags & SEC_ALLOC) == 0)
1772 {
1773 DPRINTF1 ("\tSkipping non-loaded section\n");
1774 return;
1775 }
1776
1777 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
1778 {
1779 symbolS *s = fixp->fx_addsy;
1780 bfd_reloc_code_real_type reloc;
1781 int non_pic_p;
1782 int opindex;
1783 const CGEN_OPERAND *operand;
1784 const CGEN_INSN *insn = fixp->fx_cgen.insn;
1785
1786 if (fixp->fx_done)
1787 {
1788 DPRINTF1 ("\tSkipping reloc that has already been done\n");
1789 continue;
1790 }
1791
1792 if (fixp->fx_pcrel)
1793 {
1794 DPRINTF1 ("\tSkipping reloc that is PC relative\n");
1795 continue;
1796 }
1797
1798 if (! s)
1799 {
1800 DPRINTF1 ("\tSkipping reloc without symbol\n");
1801 continue;
1802 }
1803
1804 if (fixp->fx_r_type < BFD_RELOC_UNUSED)
1805 {
1806 opindex = -1;
1807 reloc = fixp->fx_r_type;
1808 }
1809 else
1810 {
1811 opindex = (int) fixp->fx_r_type - (int) BFD_RELOC_UNUSED;
1812 operand = cgen_operand_lookup_by_num (cd, opindex);
1813 reloc = md_cgen_lookup_reloc (insn, operand, fixp);
1814 }
1815
1816 DPRINTF3 ("\treloc %s\t%s", bfd_get_reloc_code_name (reloc), S_GET_NAME (s));
1817
1818 non_pic_p = 0;
1819 switch (reloc)
1820 {
1821 default:
1822 break;
1823
1824 case BFD_RELOC_32:
1825 /* Skip relocations in known sections (.ctors, .dtors, and
1826 .gcc_except_table) since we can fix those up by hand. Also
1827 skip forward references to constants. Also skip a difference
1828 of two symbols, which still uses the BFD_RELOC_32 at this
1829 point. */
1830 if (! known_section_p
1831 && S_GET_SEGMENT (s) != absolute_section
1832 && !fixp->fx_subsy
1833 && (flags & (SEC_READONLY | SEC_CODE)) == 0)
1834 {
1835 non_pic_p = 1;
1836 }
1837 break;
1838
1839 /* FIXME -- should determine if any of the GP relocation really uses
1840 gr16 (which is not pic safe) or not. Right now, assume if we
1841 aren't being compiled with -mpic, the usage is non pic safe, but
1842 is safe with -mpic. */
1843 case BFD_RELOC_FRV_GPREL12:
1844 case BFD_RELOC_FRV_GPRELU12:
1845 case BFD_RELOC_FRV_GPREL32:
1846 case BFD_RELOC_FRV_GPRELHI:
1847 case BFD_RELOC_FRV_GPRELLO:
1848 non_pic_p = ! frv_pic_p;
1849 break;
1850
1851 case BFD_RELOC_FRV_LO16:
1852 case BFD_RELOC_FRV_HI16:
1853 if (S_GET_SEGMENT (s) != absolute_section)
1854 non_pic_p = 1;
1855 break;
1856
1857 case BFD_RELOC_VTABLE_INHERIT:
1858 case BFD_RELOC_VTABLE_ENTRY:
1859 non_pic_p = 1;
1860 break;
1861
1862 /* If this is a blessed BFD_RELOC_32, convert it back to the normal
1863 relocation. */
1864 case BFD_RELOC_CTOR:
1865 fixp->fx_r_type = BFD_RELOC_32;
1866 break;
1867 }
1868
1869 if (non_pic_p)
1870 {
1871 DPRINTF1 (" (Non-pic relocation)\n");
1872 if (frv_pic_p)
1873 as_warn_where (fixp->fx_file, fixp->fx_line,
1874 _("Relocation %s is not safe for %s"),
1875 bfd_get_reloc_code_name (reloc), frv_pic_flag);
1876
1877 else if ((frv_flags & EF_FRV_NON_PIC_RELOCS) == 0)
1878 {
1879 frv_flags |= EF_FRV_NON_PIC_RELOCS;
1880 bfd_set_private_flags (abfd, frv_flags);
1881 }
1882 }
1883 #ifdef DEBUG
1884 else
1885 DPRINTF1 ("\n");
1886 #endif
1887 }
1888 }
1889
1890 /* After all of the symbols have been adjusted, go over the file looking
1891 for any relocations that pic won't support. */
1892
1893 void
1894 frv_frob_file ()
1895 {
1896 bfd_map_over_sections (stdoutput, frv_frob_file_section, (PTR)0);
1897 }
1898
1899 void
1900 frv_frob_label (this_label)
1901 symbolS *this_label;
1902 {
1903 struct vliw_insn_list *vliw_insn_list_entry;
1904
1905 if (frv_mach != bfd_mach_frvtomcat)
1906 return;
1907
1908 if (now_seg != text_section)
1909 return;
1910
1911 vliw_insn_list_entry = frv_insert_vliw_insn(DONT_COUNT);
1912 vliw_insn_list_entry->type = VLIW_LABEL_TYPE;
1913 vliw_insn_list_entry->sym = this_label;
1914 }
1915
1916 fixS *
1917 frv_cgen_record_fixup_exp (frag, where, insn, length, operand, opinfo, exp)
1918 fragS * frag;
1919 int where;
1920 const CGEN_INSN * insn;
1921 int length;
1922 const CGEN_OPERAND * operand;
1923 int opinfo;
1924 expressionS * exp;
1925 {
1926 fixS * fixP = gas_cgen_record_fixup_exp (frag, where, insn, length,
1927 operand, opinfo, exp);
1928
1929 if (frv_mach == bfd_mach_frvtomcat
1930 && current_vliw_insn
1931 && current_vliw_insn->type == VLIW_BRANCH_TYPE
1932 && exp != NULL)
1933 current_vliw_insn->sym = exp->X_add_symbol;
1934
1935 return fixP;
1936 }
binutils for building for Google Native Client (NaCl)