OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gas/] [config/] [tc-rx.c] - Blame information for rev 160

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 16 khays
/* tc-rx.c -- Assembler for the Renesas RX
2
   Copyright 2008, 2009, 2010
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 the Free
19
   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
20
   02110-1301, USA.  */
21
 
22
#include "as.h"
23
#include "struc-symbol.h"
24
#include "obstack.h"
25
#include "safe-ctype.h"
26
#include "dwarf2dbg.h"
27
#include "libbfd.h"
28
#include "elf/common.h"
29
#include "elf/rx.h"
30
#include "rx-defs.h"
31
#include "filenames.h"
32
#include "listing.h"
33
#include "sb.h"
34
#include "macro.h"
35
 
36
#define RX_OPCODE_BIG_ENDIAN 0
37
 
38
const char comment_chars[]        = ";";
39
/* Note that input_file.c hand checks for '#' at the beginning of the
40
   first line of the input file.  This is because the compiler outputs
41
   #NO_APP at the beginning of its output.  */
42
const char line_comment_chars[]   = "#";
43
const char line_separator_chars[] = "!";
44
 
45
const char EXP_CHARS[]            = "eE";
46
const char FLT_CHARS[]            = "dD";
47
 
48
/* ELF flags to set in the output file header.  */
49
static int elf_flags = 0;
50
 
51
bfd_boolean rx_use_conventional_section_names = FALSE;
52
static bfd_boolean rx_use_small_data_limit = FALSE;
53
 
54
enum options
55
{
56
  OPTION_BIG = OPTION_MD_BASE,
57
  OPTION_LITTLE,
58
  OPTION_32BIT_DOUBLES,
59
  OPTION_64BIT_DOUBLES,
60
  OPTION_CONVENTIONAL_SECTION_NAMES,
61
  OPTION_RENESAS_SECTION_NAMES,
62
  OPTION_SMALL_DATA_LIMIT,
63
  OPTION_RELAX
64
};
65
 
66
#define RX_SHORTOPTS ""
67
const char * md_shortopts = RX_SHORTOPTS;
68
 
69
/* Assembler options.  */
70
struct option md_longopts[] =
71
{
72
  {"mbig-endian-data", no_argument, NULL, OPTION_BIG},
73
  {"mlittle-endian-data", no_argument, NULL, OPTION_LITTLE},
74
  /* The next two switches are here because the
75
     generic parts of the linker testsuite uses them.  */
76
  {"EB", no_argument, NULL, OPTION_BIG},
77
  {"EL", no_argument, NULL, OPTION_LITTLE},
78
  {"m32bit-doubles", no_argument, NULL, OPTION_32BIT_DOUBLES},
79
  {"m64bit-doubles", no_argument, NULL, OPTION_64BIT_DOUBLES},
80
  /* This option is here mainly for the binutils testsuites,
81
     as many of their tests assume conventional section naming.  */
82
  {"muse-conventional-section-names", no_argument, NULL, OPTION_CONVENTIONAL_SECTION_NAMES},
83
  {"muse-renesas-section-names", no_argument, NULL, OPTION_RENESAS_SECTION_NAMES},
84
  {"msmall-data-limit", no_argument, NULL, OPTION_SMALL_DATA_LIMIT},
85
  {"relax", no_argument, NULL, OPTION_RELAX},
86
  {NULL, no_argument, NULL, 0}
87
};
88
size_t md_longopts_size = sizeof (md_longopts);
89
 
90
int
91
md_parse_option (int c ATTRIBUTE_UNUSED, char * arg ATTRIBUTE_UNUSED)
92
{
93
  switch (c)
94
    {
95
    case OPTION_BIG:
96
      target_big_endian = 1;
97
      return 1;
98
 
99
    case OPTION_LITTLE:
100
      target_big_endian = 0;
101
      return 1;
102
 
103
    case OPTION_32BIT_DOUBLES:
104
      elf_flags &= ~ E_FLAG_RX_64BIT_DOUBLES;
105
      return 1;
106
 
107
    case OPTION_64BIT_DOUBLES:
108
      elf_flags |= E_FLAG_RX_64BIT_DOUBLES;
109
      return 1;
110
 
111
    case OPTION_CONVENTIONAL_SECTION_NAMES:
112
      rx_use_conventional_section_names = TRUE;
113
      return 1;
114
 
115
    case OPTION_RENESAS_SECTION_NAMES:
116
      rx_use_conventional_section_names = FALSE;
117
      return 1;
118
 
119
    case OPTION_SMALL_DATA_LIMIT:
120
      rx_use_small_data_limit = TRUE;
121
      return 1;
122
 
123
    case OPTION_RELAX:
124
      linkrelax = 1;
125
      return 1;
126
    }
127
  return 0;
128
}
129
 
130
void
131
md_show_usage (FILE * stream)
132
{
133
  fprintf (stream, _(" RX specific command line options:\n"));
134
  fprintf (stream, _("  --mbig-endian-data\n"));
135
  fprintf (stream, _("  --mlittle-endian-data [default]\n"));
136
  fprintf (stream, _("  --m32bit-doubles [default]\n"));
137
  fprintf (stream, _("  --m64bit-doubles\n"));
138
  fprintf (stream, _("  --muse-conventional-section-names\n"));
139
  fprintf (stream, _("  --muse-renesas-section-names [default]\n"));
140
  fprintf (stream, _("  --msmall-data-limit\n"));
141
}
142
 
143
static void
144
s_bss (int ignore ATTRIBUTE_UNUSED)
145
{
146
  int temp;
147
 
148
  temp = get_absolute_expression ();
149
  subseg_set (bss_section, (subsegT) temp);
150
  demand_empty_rest_of_line ();
151
}
152
 
153
static void
154
rx_float_cons (int ignore ATTRIBUTE_UNUSED)
155
{
156
  if (elf_flags & E_FLAG_RX_64BIT_DOUBLES)
157
    return float_cons ('d');
158
  return float_cons ('f');
159
}
160
 
161
static char *
162
rx_strcasestr (const char *string, const char *sub)
163
{
164
  int subl;
165
  int strl;
166
 
167
  if (!sub || !sub[0])
168
    return (char *)string;
169
 
170
  subl = strlen (sub);
171
  strl = strlen (string);
172
 
173
  while (strl >= subl)
174
    {
175
      /* strncasecmp is in libiberty.  */
176
      if (strncasecmp (string, sub, subl) == 0)
177
        return (char *)string;
178
 
179
      string ++;
180
      strl --;
181
    }
182
  return NULL;
183
}
184
 
185
static void
186
rx_include (int ignore)
187
{
188
  FILE * try;
189
  char * path;
190
  char * filename;
191
  char * current_filename;
192
  char * eof;
193
  char * p;
194
  char * d;
195
  char * f;
196
  char   end_char;
197
  size_t len;
198
 
199
  /* The RX version of the .INCLUDE pseudo-op does not
200
     have to have the filename inside double quotes.  */
201
  SKIP_WHITESPACE ();
202
  if (*input_line_pointer == '"')
203
    {
204
      /* Treat as the normal GAS .include pseudo-op.  */
205
      s_include (ignore);
206
      return;
207
    }
208
 
209
  /* Get the filename.  Spaces are allowed, NUL characters are not.  */
210
  filename = input_line_pointer;
211
  eof = find_end_of_line (filename, FALSE);
212
  input_line_pointer = eof;
213
 
214
  while (eof >= filename && (* eof == ' ' || * eof == '\n'))
215
    -- eof;
216
  end_char = *(++ eof);
217
  * eof = 0;
218
  if (eof == filename)
219
    {
220
      as_bad (_("no filename following .INCLUDE pseudo-op"));
221
      * eof = end_char;
222
      return;
223
    }
224
 
225
  as_where (& current_filename, NULL);
226
  f = (char *) xmalloc (strlen (current_filename) + strlen (filename) + 1);
227
 
228
  /* Check the filename.  If [@]..FILE[@] is found then replace
229
     this with the current assembler source filename, stripped
230
     of any directory prefixes or extensions.  */
231
  if ((p = rx_strcasestr (filename, "..file")) != NULL)
232
    {
233
      char * c;
234
 
235
      len = 6; /* strlen ("..file"); */
236
 
237
      if (p > filename && p[-1] == '@')
238
        -- p, ++len;
239
 
240
      if (p[len] == '@')
241
        len ++;
242
 
243
      for (d = c = current_filename; *c; c++)
244
        if (IS_DIR_SEPARATOR (* c))
245
          d = c + 1;
246
      for (c = d; *c; c++)
247
        if (*c == '.')
248
          break;
249
 
250
      sprintf (f, "%.*s%.*s%.*s", (int) (p - filename), filename,
251
               (int) (c - d), d,
252
               (int) (strlen (filename) - ((p + len) - filename)),
253
               p + len);
254
    }
255
  else
256
    strcpy (f, filename);
257
 
258
  /* RX .INCLUDE semantics say that 'filename' is located by:
259
 
260
     1. If filename is absolute, just try that.  Otherwise...
261
 
262
     2. If the current source file includes a directory component
263
        then prepend that to the filename and try.  Otherwise...
264
 
265
     3. Try any directories specified by the -I command line
266
        option(s).
267
 
268
     4 .Try a directory specifed by the INC100 environment variable.  */
269
 
270
  if (IS_ABSOLUTE_PATH (f))
271
    try = fopen (path = f, FOPEN_RT);
272
  else
273
    {
274
      char * env = getenv ("INC100");
275
 
276
      try = NULL;
277
 
278
      len = strlen (current_filename);
279
      if ((size_t) include_dir_maxlen > len)
280
        len = include_dir_maxlen;
281
      if (env && strlen (env) > len)
282
        len = strlen (env);
283
 
284
      path = (char *) xmalloc (strlen (f) + len + 5);
285
 
286
      if (current_filename != NULL)
287
        {
288
          for (d = NULL, p = current_filename; *p; p++)
289
            if (IS_DIR_SEPARATOR (* p))
290
              d = p;
291
 
292
          if (d != NULL)
293
            {
294
              sprintf (path, "%.*s/%s", (int) (d - current_filename), current_filename,
295
                       f);
296
              try = fopen (path, FOPEN_RT);
297
            }
298
        }
299
 
300
      if (try == NULL)
301
        {
302
          int i;
303
 
304
          for (i = 0; i < include_dir_count; i++)
305
            {
306
              sprintf (path, "%s/%s", include_dirs[i], f);
307
              if ((try = fopen (path, FOPEN_RT)) != NULL)
308
                break;
309
            }
310
        }
311
 
312
      if (try == NULL && env != NULL)
313
        {
314
          sprintf (path, "%s/%s", env, f);
315
          try = fopen (path, FOPEN_RT);
316
        }
317
 
318
      free (f);
319
    }
320
 
321
  if (try == NULL)
322
    {
323
      as_bad (_("unable to locate include file: %s"), filename);
324
      free (path);
325
    }
326
  else
327
    {
328
      fclose (try);
329
      register_dependency (path);
330
      input_scrub_insert_file (path);
331
    }
332
 
333
  * eof = end_char;
334
}
335
 
336
static void
337
parse_rx_section (char * name)
338
{
339
  asection * sec;
340
  int   type;
341
  int   attr = SHF_ALLOC | SHF_EXECINSTR;
342
  int   align = 2;
343
  char  end_char;
344
 
345
  do
346
    {
347
      char * p;
348
 
349
      SKIP_WHITESPACE ();
350
      for (p = input_line_pointer; *p && strchr ("\n\t, =", *p) == NULL; p++)
351
        ;
352
      end_char = *p;
353
      *p = 0;
354
 
355
      if (strcasecmp (input_line_pointer, "ALIGN") == 0)
356
        {
357
          *p = end_char;
358
 
359
          if (end_char == ' ')
360
            while (ISSPACE (*p))
361
              p++;
362
 
363
          if (*p == '=')
364
            {
365
              ++ p;
366
              while (ISSPACE (*p))
367
                p++;
368
              switch (*p)
369
                {
370
                case '2': align = 2; break;
371
                case '4': align = 4; break;
372
                case '8': align = 8; break;
373
                default:
374
                  as_bad (_("unrecognised alignment value in .SECTION directive: %s"), p);
375
                  ignore_rest_of_line ();
376
                  return;
377
                }
378
              ++ p;
379
            }
380
 
381
          end_char = *p;
382
        }
383
      else if (strcasecmp (input_line_pointer, "CODE") == 0)
384
        attr = SHF_ALLOC | SHF_EXECINSTR;
385
      else if (strcasecmp (input_line_pointer, "DATA") == 0)
386
        attr = SHF_ALLOC | SHF_WRITE;
387
      else if (strcasecmp (input_line_pointer, "ROMDATA") == 0)
388
        attr = SHF_ALLOC;
389
      else
390
        {
391
          as_bad (_("unknown parameter following .SECTION directive: %s"),
392
                  input_line_pointer);
393
 
394
          *p = end_char;
395
          input_line_pointer = p + 1;
396
          ignore_rest_of_line ();
397
          return;
398
        }
399
 
400
      *p = end_char;
401
      input_line_pointer = p + 1;
402
    }
403
  while (end_char != '\n' && end_char != 0);
404
 
405
  if ((sec = bfd_get_section_by_name (stdoutput, name)) == NULL)
406
    {
407
      if (strcmp (name, "B") && strcmp (name, "B_1") && strcmp (name, "B_2"))
408
        type = SHT_NULL;
409
      else
410
        type = SHT_NOBITS;
411
 
412
      obj_elf_change_section (name, type, attr, 0, NULL, FALSE, FALSE);
413
    }
414
  else /* Try not to redefine a section, especially B_1.  */
415
    {
416
      int flags = sec->flags;
417
 
418
      type = elf_section_type (sec);
419
 
420
      attr = ((flags & SEC_READONLY) ? 0 : SHF_WRITE)
421
        | ((flags & SEC_ALLOC) ? SHF_ALLOC : 0)
422
        | ((flags & SEC_CODE) ? SHF_EXECINSTR : 0)
423
        | ((flags & SEC_MERGE) ? SHF_MERGE : 0)
424
        | ((flags & SEC_STRINGS) ? SHF_STRINGS : 0)
425
        | ((flags & SEC_THREAD_LOCAL) ? SHF_TLS : 0);
426
 
427
      obj_elf_change_section (name, type, attr, 0, NULL, FALSE, FALSE);
428
    }
429
 
430
  bfd_set_section_alignment (stdoutput, now_seg, align);
431
}
432
 
433
static void
434
rx_section (int ignore)
435
{
436
  char * p;
437
 
438
  /* The as100 assembler supports a different syntax for the .section
439
     pseudo-op.  So check for it and handle it here if necessary. */
440
  SKIP_WHITESPACE ();
441
 
442
  /* Peek past the section name to see if arguments follow.  */
443
  for (p = input_line_pointer; *p; p++)
444
    if (*p == ',' || *p == '\n')
445
      break;
446
 
447
  if (*p == ',')
448
    {
449
      int len = p - input_line_pointer;
450
 
451
      while (ISSPACE (*++p))
452
        ;
453
 
454
      if (*p != '"' && *p != '#')
455
        {
456
          char * name = (char *) xmalloc (len + 1);
457
 
458
          strncpy (name, input_line_pointer, len);
459
          name[len] = 0;
460
 
461
          input_line_pointer = p;
462
          parse_rx_section (name);
463
          return;
464
        }
465
    }
466
 
467
  obj_elf_section (ignore);
468
}
469
 
470
static void
471
rx_list (int ignore ATTRIBUTE_UNUSED)
472
{
473
  SKIP_WHITESPACE ();
474
 
475
  if (strncasecmp (input_line_pointer, "OFF", 3))
476
    listing_list (0);
477
  else if (strncasecmp (input_line_pointer, "ON", 2))
478
    listing_list (1);
479
  else
480
    as_warn (_("expecting either ON or OFF after .list"));
481
}
482
 
483
/* Like the .rept pseudo op, but supports the
484
   use of ..MACREP inside the repeated region.  */
485
 
486
static void
487
rx_rept (int ignore ATTRIBUTE_UNUSED)
488
{
489
  int count = get_absolute_expression ();
490
 
491
  do_repeat_with_expander (count, "MREPEAT", "ENDR", "..MACREP");
492
}
493
 
494
/* Like cons() accept that strings are allowed.  */
495
 
496
static void
497
rx_cons (int size)
498
{
499
  SKIP_WHITESPACE ();
500
 
501
  if (* input_line_pointer == '"')
502
    stringer (8+0);
503
  else
504
    cons (size);
505
}
506
 
507
static void
508
rx_nop (int ignore ATTRIBUTE_UNUSED)
509
{
510
  ignore_rest_of_line ();
511
}
512
 
513
static void
514
rx_unimp (int idx)
515
{
516
  as_warn (_("The \".%s\" pseudo-op is not implemented\n"),
517
           md_pseudo_table[idx].poc_name);
518
  ignore_rest_of_line ();
519
}
520
 
521
/* The target specific pseudo-ops which we support.  */
522
const pseudo_typeS md_pseudo_table[] =
523
{
524
  /* These are unimplemented.  They're listed first so that we can use
525
     the poc_value as the index into this array, to get the name of
526
     the pseudo.  So, keep these (1) first, and (2) in order, with (3)
527
     the poc_value's in sequence.  */
528
  { "btglb",    rx_unimp,       0 },
529
  { "call",     rx_unimp,       1 },
530
  { "einsf",    rx_unimp,       2 },
531
  { "fb",       rx_unimp,       3 },
532
  { "fbsym",    rx_unimp,       4 },
533
  { "id",       rx_unimp,       5 },
534
  { "initsct",  rx_unimp,       6 },
535
  { "insf",     rx_unimp,       7 },
536
  { "instr",    rx_unimp,       8 },
537
  { "lbba",     rx_unimp,       9 },
538
  { "len",      rx_unimp,       10 },
539
  { "optj",     rx_unimp,       11 },
540
  { "rvector",  rx_unimp,       12 },
541
  { "sb",       rx_unimp,       13 },
542
  { "sbbit",    rx_unimp,       14 },
543
  { "sbsym",    rx_unimp,       15 },
544
  { "sbsym16",  rx_unimp,       16 },
545
 
546
  /* These are the do-nothing pseudos.  */
547
  { "stk",      rx_nop,         0 },
548
  /* The manual documents ".stk" but the compiler emits ".stack".  */
549
  { "stack",    rx_nop,         0 },
550
 
551
  /* These are Renesas as100 assembler pseudo-ops that we do support.  */
552
  { "addr",     rx_cons,        3 },
553
  { "align",    s_align_bytes,  2 },
554
  { "byte",     rx_cons,        1 },
555
  { "fixed",    float_cons,    'f' },
556
  { "form",     listing_psize,  0 },
557
  { "glb",      s_globl,        0 },
558
  { "include",  rx_include,     0 },
559
  { "list",     rx_list,        0 },
560
  { "lword",    rx_cons,        4 },
561
  { "mrepeat",  rx_rept,        0 },
562
  { "section",  rx_section,     0 },
563
 
564
  /* FIXME: The following pseudo-ops place their values (and associated
565
     label if present) in the data section, regardless of whatever
566
     section we are currently in.  At the moment this code does not
567
     implement that part of the semantics.  */
568
  { "blka",     s_space,        3 },
569
  { "blkb",     s_space,        1 },
570
  { "blkd",     s_space,        8 },
571
  { "blkf",     s_space,        4 },
572
  { "blkl",     s_space,        4 },
573
  { "blkw",     s_space,        2 },
574
 
575
  /* Our "standard" pseudos. */
576
  { "double",   rx_float_cons,  0 },
577
  { "bss",      s_bss,          0 },
578
  { "3byte",    cons,           3 },
579
  { "int",      cons,           4 },
580
  { "word",     cons,           4 },
581
 
582
  /* End of list marker.  */
583
  { NULL,       NULL,           0 }
584
};
585
 
586
static asymbol * gp_symbol;
587
 
588
void
589
md_begin (void)
590
{
591
  if (rx_use_small_data_limit)
592
    /* Make the __gp symbol now rather
593
       than after the symbol table is frozen.  We only do this
594
       when supporting small data limits because otherwise we
595
       pollute the symbol table.  */
596
    gp_symbol = symbol_get_bfdsym (symbol_find_or_make ("__gp"));
597
}
598
 
599
char * rx_lex_start;
600
char * rx_lex_end;
601
 
602
typedef struct rx_bytesT
603
{
604
  char base[4];
605
  int n_base;
606
  char ops[8];
607
  int n_ops;
608
  struct
609
  {
610
    expressionS  exp;
611
    char         offset;
612
    char         nbits;
613
    char         type; /* RXREL_*.  */
614
    int          reloc;
615
    fixS *       fixP;
616
  } fixups[2];
617
  int n_fixups;
618
  struct
619
  {
620
    char type;
621
    char field_pos;
622
    char val_ofs;
623
  } relax[2];
624
  int n_relax;
625
  int link_relax;
626
  fixS *link_relax_fixP;
627
  char times_grown;
628
  char times_shrank;
629
} rx_bytesT;
630
 
631
static rx_bytesT rx_bytes;
632
 
633
void
634
rx_relax (int type, int pos)
635
{
636
  rx_bytes.relax[rx_bytes.n_relax].type = type;
637
  rx_bytes.relax[rx_bytes.n_relax].field_pos = pos;
638
  rx_bytes.relax[rx_bytes.n_relax].val_ofs = rx_bytes.n_base + rx_bytes.n_ops;
639
  rx_bytes.n_relax ++;
640
}
641
 
642
void
643
rx_linkrelax_dsp (int pos)
644
{
645
  switch (pos)
646
    {
647
    case 4:
648
      rx_bytes.link_relax |= RX_RELAXA_DSP4;
649
      break;
650
    case 6:
651
      rx_bytes.link_relax |= RX_RELAXA_DSP6;
652
      break;
653
    case 14:
654
      rx_bytes.link_relax |= RX_RELAXA_DSP14;
655
      break;
656
    }
657
}
658
 
659
void
660
rx_linkrelax_imm (int pos)
661
{
662
  switch (pos)
663
    {
664
    case 6:
665
      rx_bytes.link_relax |= RX_RELAXA_IMM6;
666
      break;
667
    case 12:
668
      rx_bytes.link_relax |= RX_RELAXA_IMM12;
669
      break;
670
    }
671
}
672
 
673
void
674
rx_linkrelax_branch (void)
675
{
676
  rx_bytes.link_relax |= RX_RELAXA_BRA;
677
}
678
 
679
static void
680
rx_fixup (expressionS exp, int offsetbits, int nbits, int type)
681
{
682
  rx_bytes.fixups[rx_bytes.n_fixups].exp = exp;
683
  rx_bytes.fixups[rx_bytes.n_fixups].offset = offsetbits;
684
  rx_bytes.fixups[rx_bytes.n_fixups].nbits = nbits;
685
  rx_bytes.fixups[rx_bytes.n_fixups].type = type;
686
  rx_bytes.fixups[rx_bytes.n_fixups].reloc = exp.X_md;
687
  rx_bytes.n_fixups ++;
688
}
689
 
690
#define rx_field_fixup(exp, offset, nbits, type)        \
691
  rx_fixup (exp, offset, nbits, type)
692
 
693
#define rx_op_fixup(exp, offset, nbits, type)           \
694
  rx_fixup (exp, offset + 8 * rx_bytes.n_base, nbits, type)
695
 
696
void
697
rx_base1 (int b1)
698
{
699
  rx_bytes.base[0] = b1;
700
  rx_bytes.n_base = 1;
701
}
702
 
703
void
704
rx_base2 (int b1, int b2)
705
{
706
  rx_bytes.base[0] = b1;
707
  rx_bytes.base[1] = b2;
708
  rx_bytes.n_base = 2;
709
}
710
 
711
void
712
rx_base3 (int b1, int b2, int b3)
713
{
714
  rx_bytes.base[0] = b1;
715
  rx_bytes.base[1] = b2;
716
  rx_bytes.base[2] = b3;
717
  rx_bytes.n_base = 3;
718
}
719
 
720
void
721
rx_base4 (int b1, int b2, int b3, int b4)
722
{
723
  rx_bytes.base[0] = b1;
724
  rx_bytes.base[1] = b2;
725
  rx_bytes.base[2] = b3;
726
  rx_bytes.base[3] = b4;
727
  rx_bytes.n_base = 4;
728
}
729
 
730
/* This gets complicated when the field spans bytes, because fields
731
   are numbered from the MSB of the first byte as zero, and bits are
732
   stored LSB towards the LSB of the byte.  Thus, a simple four-bit
733
   insertion of 12 at position 4 of 0x00 yields: 0x0b.  A three-bit
734
   insertion of b'MXL at position 7 is like this:
735
 
736
     - - - -  - - - -   - - - -  - - - -
737
                    M   X L               */
738
 
739
void
740
rx_field (int val, int pos, int sz)
741
{
742
  int valm;
743
  int bytep, bitp;
744
 
745
  if (sz > 0)
746
    {
747
      if (val < 0 || val >= (1 << sz))
748
        as_bad (_("Value %d doesn't fit in unsigned %d-bit field"), val, sz);
749
    }
750
  else
751
    {
752
      sz = - sz;
753
      if (val < -(1 << (sz - 1)) || val >= (1 << (sz - 1)))
754
        as_bad (_("Value %d doesn't fit in signed %d-bit field"), val, sz);
755
    }
756
 
757
  /* This code points at 'M' in the above example.  */
758
  bytep = pos / 8;
759
  bitp = pos % 8;
760
 
761
  while (bitp + sz > 8)
762
    {
763
      int ssz = 8 - bitp;
764
      int svalm;
765
 
766
      svalm = val >> (sz - ssz);
767
      svalm = svalm & ((1 << ssz) - 1);
768
      svalm = svalm << (8 - bitp - ssz);
769
      gas_assert (bytep < rx_bytes.n_base);
770
      rx_bytes.base[bytep] |= svalm;
771
 
772
      bitp = 0;
773
      sz -= ssz;
774
      bytep ++;
775
    }
776
  valm = val & ((1 << sz) - 1);
777
  valm = valm << (8 - bitp - sz);
778
  gas_assert (bytep < rx_bytes.n_base);
779
  rx_bytes.base[bytep] |= valm;
780
}
781
 
782
/* Special case of the above, for 3-bit displacements of 2..9.  */
783
 
784
void
785
rx_disp3 (expressionS exp, int pos)
786
{
787
  rx_field_fixup (exp, pos, 3, RXREL_PCREL);
788
}
789
 
790
/* Special case of the above, for split 5-bit displacements.  Assumes
791
   the displacement has been checked with rx_disp5op.  */
792
/* ---- -432 1--- 0--- */
793
 
794
void
795
rx_field5s (expressionS exp)
796
{
797
  int val;
798
 
799
  val = exp.X_add_number;
800
  rx_bytes.base[0] |= val >> 2;
801
  rx_bytes.base[1] |= (val << 6) & 0x80;
802
  rx_bytes.base[1] |= (val << 3) & 0x08;
803
}
804
 
805
/* ---- ---- 4--- 3210 */
806
 
807
void
808
rx_field5s2 (expressionS exp)
809
{
810
  int val;
811
 
812
  val = exp.X_add_number;
813
  rx_bytes.base[1] |= (val << 3) & 0x80;
814
  rx_bytes.base[1] |= (val     ) & 0x0f;
815
}
816
 
817
#define OP(x) rx_bytes.ops[rx_bytes.n_ops++] = (x)
818
 
819
#define F_PRECISION 2
820
 
821
void
822
rx_op (expressionS exp, int nbytes, int type)
823
{
824
  int v = 0;
825
 
826
  if ((exp.X_op == O_constant || exp.X_op == O_big)
827
      && type != RXREL_PCREL)
828
    {
829
      if (exp.X_op == O_big && exp.X_add_number <= 0)
830
        {
831
          LITTLENUM_TYPE w[2];
832
          char * ip = rx_bytes.ops + rx_bytes.n_ops;
833
 
834
          gen_to_words (w, F_PRECISION, 8);
835
#if RX_OPCODE_BIG_ENDIAN
836
          ip[0] = w[0] >> 8;
837
          ip[1] = w[0];
838
          ip[2] = w[1] >> 8;
839
          ip[3] = w[1];
840
#else
841
          ip[3] = w[0] >> 8;
842
          ip[2] = w[0];
843
          ip[1] = w[1] >> 8;
844
          ip[0] = w[1];
845
#endif
846
          rx_bytes.n_ops += 4;
847
        }
848
      else
849
        {
850
          v = exp.X_add_number;
851
          while (nbytes)
852
            {
853
#if RX_OPCODE_BIG_ENDIAN
854
              OP ((v >> (8 * (nbytes - 1))) & 0xff);
855
#else
856
              OP (v & 0xff);
857
              v >>= 8;
858
#endif
859
              nbytes --;
860
            }
861
        }
862
    }
863
  else
864
    {
865
      rx_op_fixup (exp, rx_bytes.n_ops * 8, nbytes * 8, type);
866
      memset (rx_bytes.ops + rx_bytes.n_ops, 0, nbytes);
867
      rx_bytes.n_ops += nbytes;
868
    }
869
}
870
 
871
int
872
rx_wrap (void)
873
{
874
  return 0;
875
}
876
 
877
#define APPEND(B, N_B)                                 \
878
  if (rx_bytes.N_B)                                    \
879
    {                                                  \
880
      memcpy (bytes + idx, rx_bytes.B, rx_bytes.N_B);  \
881
      idx += rx_bytes.N_B;                             \
882
    }
883
 
884
void
885
rx_frag_init (fragS * fragP)
886
{
887
  if (rx_bytes.n_relax || rx_bytes.link_relax)
888
    {
889
      fragP->tc_frag_data = malloc (sizeof (rx_bytesT));
890
      memcpy (fragP->tc_frag_data, & rx_bytes, sizeof (rx_bytesT));
891
    }
892
  else
893
    fragP->tc_frag_data = 0;
894
}
895
 
896
/* Handle the as100's version of the .equ pseudo-op.  It has the syntax:
897
   <symbol_name> .equ <expression>   */
898
 
899
static void
900
rx_equ (char * name, char * expression)
901
{
902
  char   saved_name_end_char;
903
  char * name_end;
904
  char * saved_ilp;
905
 
906
  while (ISSPACE (* name))
907
    name ++;
908
 
909
  for (name_end = name + 1; *name_end; name_end ++)
910
    if (! ISALNUM (* name_end))
911
      break;
912
 
913
  saved_name_end_char = * name_end;
914
  * name_end = 0;
915
 
916
  saved_ilp = input_line_pointer;
917
  input_line_pointer = expression;
918
 
919
  equals (name, 1);
920
 
921
  input_line_pointer = saved_ilp;
922
  * name_end = saved_name_end_char;
923
}
924
 
925
/* Look for Renesas as100 pseudo-ops that occur after a symbol name
926
   rather than at the start of a line.  (eg .EQU or .DEFINE).  If one
927
   is found, process it and return TRUE otherwise return FALSE.  */
928
 
929
static bfd_boolean
930
scan_for_infix_rx_pseudo_ops (char * str)
931
{
932
  char * p;
933
  char * pseudo_op;
934
  char * dot = strchr (str, '.');
935
 
936
  if (dot == NULL || dot == str)
937
    return FALSE;
938
 
939
  /* A real pseudo-op must be preceeded by whitespace.  */
940
  if (dot[-1] != ' ' && dot[-1] != '\t')
941
    return FALSE;
942
 
943
  pseudo_op = dot + 1;
944
 
945
  if (!ISALNUM (* pseudo_op))
946
    return FALSE;
947
 
948
  for (p = pseudo_op + 1; ISALNUM (* p); p++)
949
    ;
950
 
951
  if (strncasecmp ("EQU", pseudo_op, p - pseudo_op) == 0)
952
    rx_equ (str, p);
953
  else if (strncasecmp ("DEFINE", pseudo_op, p - pseudo_op) == 0)
954
    as_warn (_("The .DEFINE pseudo-op is not implemented"));
955
  else if (strncasecmp ("MACRO", pseudo_op, p - pseudo_op) == 0)
956
    as_warn (_("The .MACRO pseudo-op is not implemented"));
957
  else if (strncasecmp ("BTEQU", pseudo_op, p - pseudo_op) == 0)
958
    as_warn (_("The .BTEQU pseudo-op is not implemented."));
959
  else
960
    return FALSE;
961
 
962
  return TRUE;
963
}
964
 
965
void
966
md_assemble (char * str)
967
{
968
  char * bytes;
969
  int idx = 0;
970
  int i, rel;
971
  fragS * frag_then = frag_now;
972
  expressionS  *exp;
973
 
974
  memset (& rx_bytes, 0, sizeof (rx_bytes));
975
 
976
  rx_lex_init (str, str + strlen (str));
977
  if (scan_for_infix_rx_pseudo_ops (str))
978
    return;
979
  rx_parse ();
980
 
981
  /* This simplifies the relaxation code.  */
982
  if (rx_bytes.n_relax || rx_bytes.link_relax)
983
    {
984
      /* We do it this way because we want the frag to have the
985
         rx_bytes in it, which we initialize above.  */
986
      bytes = frag_more (12);
987
      frag_then = frag_now;
988
      frag_variant (rs_machine_dependent,
989
 
990
 
991
 
992
 
993
 
994
 
995
      frag_then->fr_opcode = bytes;
996
      frag_then->fr_fix += rx_bytes.n_base + rx_bytes.n_ops;
997
      frag_then->fr_subtype = rx_bytes.n_base + rx_bytes.n_ops;
998
    }
999
  else
1000
    {
1001
      bytes = frag_more (rx_bytes.n_base + rx_bytes.n_ops);
1002
      frag_then = frag_now;
1003
    }
1004
 
1005
  APPEND (base, n_base);
1006
  APPEND (ops, n_ops);
1007
 
1008
  if (rx_bytes.link_relax && rx_bytes.n_fixups)
1009
    {
1010
      fixS * f;
1011
 
1012
      f = fix_new (frag_then,
1013
                   (char *) bytes - frag_then->fr_literal,
1014
                   0,
1015
                   abs_section_sym,
1016
                   rx_bytes.link_relax | rx_bytes.n_fixups,
1017
                   0,
1018
                   BFD_RELOC_RX_RELAX);
1019
      frag_then->tc_frag_data->link_relax_fixP = f;
1020
    }
1021
 
1022
  for (i = 0; i < rx_bytes.n_fixups; i ++)
1023
    {
1024
      /* index: [nbytes][type] */
1025
      static int reloc_map[5][4] =
1026
        {
1027
          { 0,                  0,                0,                  BFD_RELOC_RX_DIR3U_PCREL },
1028
          { BFD_RELOC_8,        BFD_RELOC_RX_8U,  BFD_RELOC_RX_NEG8,  BFD_RELOC_8_PCREL },
1029
          { BFD_RELOC_RX_16_OP, BFD_RELOC_RX_16U, BFD_RELOC_RX_NEG16, BFD_RELOC_16_PCREL },
1030
          { BFD_RELOC_RX_24_OP, BFD_RELOC_RX_24U, BFD_RELOC_RX_NEG24, BFD_RELOC_24_PCREL },
1031
          { BFD_RELOC_RX_32_OP, BFD_RELOC_32,     BFD_RELOC_RX_NEG32, BFD_RELOC_32_PCREL },
1032
        };
1033
      fixS * f;
1034
 
1035
      idx = rx_bytes.fixups[i].offset / 8;
1036
      rel = reloc_map [rx_bytes.fixups[i].nbits / 8][(int) rx_bytes.fixups[i].type];
1037
 
1038
      if (rx_bytes.fixups[i].reloc)
1039
        rel = rx_bytes.fixups[i].reloc;
1040
 
1041
      if (frag_then->tc_frag_data)
1042
        exp = & frag_then->tc_frag_data->fixups[i].exp;
1043
      else
1044
        exp = & rx_bytes.fixups[i].exp;
1045
 
1046
      f = fix_new_exp (frag_then,
1047
                       (char *) bytes + idx - frag_then->fr_literal,
1048
                       rx_bytes.fixups[i].nbits / 8,
1049
                       exp,
1050
                       rx_bytes.fixups[i].type == RXREL_PCREL ? 1 : 0,
1051
                       rel);
1052
      if (frag_then->tc_frag_data)
1053
        frag_then->tc_frag_data->fixups[i].fixP = f;
1054
    }
1055
 
1056
  dwarf2_emit_insn (idx);
1057
}
1058
 
1059
void
1060
rx_md_end (void)
1061
{
1062
}
1063
 
1064
/* Write a value out to the object file, using the appropriate endianness.  */
1065
 
1066
void
1067
md_number_to_chars (char * buf, valueT val, int n)
1068
{
1069
  if (target_big_endian)
1070
    number_to_chars_bigendian (buf, val, n);
1071
  else
1072
    number_to_chars_littleendian (buf, val, n);
1073
}
1074
 
1075
static struct
1076
{
1077
  char * fname;
1078
  int    reloc;
1079
}
1080
reloc_functions[] =
1081
{
1082
  { "gp", BFD_RELOC_GPREL16 },
1083
  { 0, 0 }
1084
};
1085
 
1086
void
1087
md_operand (expressionS * exp ATTRIBUTE_UNUSED)
1088
{
1089
  int reloc = 0;
1090
  int i;
1091
 
1092
  for (i = 0; reloc_functions[i].fname; i++)
1093
    {
1094
      int flen = strlen (reloc_functions[i].fname);
1095
 
1096
      if (input_line_pointer[0] == '%'
1097
          && strncasecmp (input_line_pointer + 1, reloc_functions[i].fname, flen) == 0
1098
          && input_line_pointer[flen + 1] == '(')
1099
        {
1100
          reloc = reloc_functions[i].reloc;
1101
          input_line_pointer += flen + 2;
1102
          break;
1103
        }
1104
    }
1105
  if (reloc == 0)
1106
    return;
1107
 
1108
  expression (exp);
1109
  if (* input_line_pointer == ')')
1110
    input_line_pointer ++;
1111
 
1112
  exp->X_md = reloc;
1113
}
1114
 
1115
valueT
1116
md_section_align (segT segment, valueT size)
1117
{
1118
  int align = bfd_get_section_alignment (stdoutput, segment);
1119
  return ((size + (1 << align) - 1) & (-1 << align));
1120
}
1121
 
1122
                                /* NOP - 1 cycle */
1123
static unsigned char nop_1[] = { 0x03};
1124
                                /* MOV.L R0,R0 - 1 cycle */
1125
static unsigned char nop_2[] = { 0xef, 0x00};
1126
                                /* MAX R0,R0 - 1 cycle */
1127
static unsigned char nop_3[] = { 0xfc, 0x13, 0x00 };
1128
                                /* MUL #1,R0 - 1 cycle */
1129
static unsigned char nop_4[] = { 0x76, 0x10, 0x01, 0x00 };
1130
                                /* MUL #1,R0 - 1 cycle */
1131
static unsigned char nop_5[] = { 0x77, 0x10, 0x01, 0x00, 0x00 };
1132
                                /* MUL #1,R0 - 1 cycle */
1133
static unsigned char nop_6[] = { 0x74, 0x10, 0x01, 0x00, 0x00, 0x00 };
1134
                                /* BRA.S .+7 - 1 cycle */
1135
static unsigned char nop_7[] = { 0x0F, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03 };
1136
 
1137
static unsigned char *nops[] = { NULL, nop_1, nop_2, nop_3, nop_4, nop_5, nop_6, nop_7 };
1138
#define BIGGEST_NOP 7
1139
 
1140
/* When relaxing, we need to output a reloc for any .align directive
1141
   so that we can retain this alignment as we adjust opcode sizes.  */
1142
void
1143
rx_handle_align (fragS * frag)
1144
{
1145
  /* If handling an alignment frag, use an optimal NOP pattern.
1146
     Only do this if a fill value has not already been provided.
1147
     FIXME: This test fails if the provided fill value is zero.  */
1148
  if ((frag->fr_type == rs_align
1149
       || frag->fr_type == rs_align_code)
1150
      && subseg_text_p (now_seg))
1151
    {
1152
      int count = (frag->fr_next->fr_address
1153
                   - frag->fr_address
1154
                   - frag->fr_fix);
1155
      unsigned char *base = (unsigned char *)frag->fr_literal + frag->fr_fix;
1156
 
1157
      if (* base == 0)
1158
        {
1159
          if (count > BIGGEST_NOP)
1160
            {
1161
              base[0] = 0x2e;
1162
              base[1] = count;
1163
              frag->fr_var = 2;
1164
            }
1165
          else if (count > 0)
1166
            {
1167
              memcpy (base, nops[count], count);
1168
              frag->fr_var = count;
1169
            }
1170
        }
1171
    }
1172
 
1173
  if (linkrelax
1174
      && (frag->fr_type == rs_align
1175
          || frag->fr_type == rs_align_code)
1176
      && frag->fr_address + frag->fr_fix > 0
1177
      && frag->fr_offset > 0
1178
      && now_seg != bss_section)
1179
    {
1180
      fix_new (frag, frag->fr_fix, 0,
1181
               &abs_symbol, RX_RELAXA_ALIGN + frag->fr_offset,
1182
               0, BFD_RELOC_RX_RELAX);
1183
      /* For the purposes of relaxation, this relocation is attached
1184
         to the byte *after* the alignment - i.e. the byte that must
1185
         remain aligned.  */
1186
      fix_new (frag->fr_next, 0, 0,
1187
               &abs_symbol, RX_RELAXA_ELIGN + frag->fr_offset,
1188
               0, BFD_RELOC_RX_RELAX);
1189
    }
1190
}
1191
 
1192
char *
1193
md_atof (int type, char * litP, int * sizeP)
1194
{
1195
  return ieee_md_atof (type, litP, sizeP, target_big_endian);
1196
}
1197
 
1198
symbolS *
1199
md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
1200
{
1201
  return NULL;
1202
}
1203
 
1204
/*----------------------------------------------------------------------*/
1205
/* To recap: we estimate everything based on md_estimate_size, then
1206
   adjust based on rx_relax_frag.  When it all settles, we call
1207
   md_convert frag to update the bytes.  The relaxation types and
1208
   relocations are in fragP->tc_frag_data, which is a copy of that
1209
   rx_bytes.
1210
 
1211
   Our scheme is as follows: fr_fix has the size of the smallest
1212
   opcode (like BRA.S).  We store the number of total bytes we need in
1213
   fr_subtype.  When we're done relaxing, we use fr_subtype and the
1214
   existing opcode bytes to figure out what actual opcode we need to
1215
   put in there.  If the fixup isn't resolvable now, we use the
1216
   maximal size.  */
1217
 
1218
#define TRACE_RELAX 0
1219
#define tprintf if (TRACE_RELAX) printf
1220
 
1221
typedef enum
1222
{
1223
  OT_other,
1224
  OT_bra,
1225
  OT_beq,
1226
  OT_bne,
1227
  OT_bsr,
1228
  OT_bcc
1229
} op_type_T;
1230
 
1231
/* We're looking for these types of relaxations:
1232
 
1233
   BRA.S        00001dsp
1234
   BRA.B        00101110 dspppppp
1235
   BRA.W        00111000 dspppppp pppppppp
1236
   BRA.A        00000100 dspppppp pppppppp pppppppp
1237
 
1238
   BEQ.S        00010dsp
1239
   BEQ.B        00100000 dspppppp
1240
   BEQ.W        00111010 dspppppp pppppppp
1241
 
1242
   BNE.S        00011dsp
1243
   BNE.B        00100001 dspppppp
1244
   BNE.W        00111011 dspppppp pppppppp
1245
 
1246
   BSR.W        00111001 dspppppp pppppppp
1247
   BSR.A        00000101 dspppppp pppppppp pppppppp
1248
 
1249
   Bcc.B        0010cond dspppppp
1250
 
1251
   Additionally, we can synthesize longer conditional branches using
1252
   pairs of opcodes, one with an inverted conditional (flip LSB):
1253
 
1254
   Bcc.W        0010ncnd 00000110 00111000 dspppppp pppppppp
1255
   Bcc.A        0010ncnd 00000111 00000100 dspppppp pppppppp pppppppp
1256
   BEQ.A        00011100 00000100 dspppppp pppppppp pppppppp
1257
   BNE.A        00010100 00000100 dspppppp pppppppp pppppppp  */
1258
 
1259
/* Given the opcode bytes at OP, figure out which opcode it is and
1260
   return the type of opcode.  We use this to re-encode the opcode as
1261
   a different size later.  */
1262
 
1263
static op_type_T
1264
rx_opcode_type (char * op)
1265
{
1266
  unsigned char b = (unsigned char) op[0];
1267
 
1268
  switch (b & 0xf8)
1269
    {
1270
    case 0x08: return OT_bra;
1271
    case 0x10: return OT_beq;
1272
    case 0x18: return OT_bne;
1273
    }
1274
 
1275
  switch (b)
1276
    {
1277
    case 0x2e: return OT_bra;
1278
    case 0x38: return OT_bra;
1279
    case 0x04: return OT_bra;
1280
 
1281
    case 0x20: return OT_beq;
1282
    case 0x3a: return OT_beq;
1283
 
1284
    case 0x21: return OT_bne;
1285
    case 0x3b: return OT_bne;
1286
 
1287
    case 0x39: return OT_bsr;
1288
    case 0x05: return OT_bsr;
1289
    }
1290
 
1291
  if ((b & 0xf0) == 0x20)
1292
    return OT_bcc;
1293
 
1294
  return OT_other;
1295
}
1296
 
1297
/* Returns zero if *addrP has the target address.  Else returns nonzero
1298
   if we cannot compute the target address yet.  */
1299
 
1300
static int
1301
rx_frag_fix_value (fragS *    fragP,
1302
                   segT       segment,
1303
                   int        which,
1304
                   addressT * addrP,
1305
                   int        need_diff,
1306
                   addressT * sym_addr)
1307
{
1308
  addressT addr = 0;
1309
  rx_bytesT * b = fragP->tc_frag_data;
1310
  expressionS * exp = & b->fixups[which].exp;
1311
 
1312
  if (need_diff && exp->X_op != O_subtract)
1313
    return 1;
1314
 
1315
  if (exp->X_add_symbol)
1316
    {
1317
      if (S_FORCE_RELOC (exp->X_add_symbol, 1))
1318
        return 1;
1319
      if (S_GET_SEGMENT (exp->X_add_symbol) != segment)
1320
        return 1;
1321
      addr += S_GET_VALUE (exp->X_add_symbol);
1322
    }
1323
 
1324
  if (exp->X_op_symbol)
1325
    {
1326
      if (exp->X_op != O_subtract)
1327
        return 1;
1328
      if (S_FORCE_RELOC (exp->X_op_symbol, 1))
1329
        return 1;
1330
      if (S_GET_SEGMENT (exp->X_op_symbol) != segment)
1331
        return 1;
1332
      addr -= S_GET_VALUE (exp->X_op_symbol);
1333
    }
1334
  if (sym_addr)
1335
    * sym_addr = addr;
1336
  addr += exp->X_add_number;
1337
  * addrP = addr;
1338
  return 0;
1339
}
1340
 
1341
/* Estimate how big the opcode is after this relax pass.  The return
1342
   value is the difference between fr_fix and the actual size.  We
1343
   compute the total size in rx_relax_frag and store it in fr_subtype,
1344
   sowe only need to subtract fx_fix and return it.  */
1345
 
1346
int
1347
md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED, segT segment ATTRIBUTE_UNUSED)
1348
{
1349
  int opfixsize;
1350
  int delta;
1351
 
1352
  tprintf ("\033[32m  est frag: addr %08lx fix %ld var %ld ofs %ld lit %p opc %p type %d sub %d\033[0m\n",
1353
           (unsigned long) (fragP->fr_address
1354
                            + (fragP->fr_opcode - fragP->fr_literal)),
1355
           (long) fragP->fr_fix, (long) fragP->fr_var, (long) fragP->fr_offset,
1356
           fragP->fr_literal, fragP->fr_opcode, fragP->fr_type, fragP->fr_subtype);
1357
 
1358
  /* This is the size of the opcode that's accounted for in fr_fix.  */
1359
  opfixsize = fragP->fr_fix - (fragP->fr_opcode - fragP->fr_literal);
1360
  /* This is the size of the opcode that isn't.  */
1361
  delta = (fragP->fr_subtype - opfixsize);
1362
 
1363
  tprintf (" -> opfixsize %d delta %d\n", opfixsize, delta);
1364
  return delta;
1365
}
1366
 
1367
/* Given the new addresses for this relax pass, figure out how big
1368
   each opcode must be.  We store the total number of bytes needed in
1369
   fr_subtype.  The return value is the difference between the size
1370
   after the last pass and the size after this pass, so we use the old
1371
   fr_subtype to calculate the difference.  */
1372
 
1373
int
1374
rx_relax_frag (segT segment ATTRIBUTE_UNUSED, fragS * fragP, long stretch)
1375
{
1376
  addressT addr0, sym_addr;
1377
  addressT mypc;
1378
  int disp;
1379
  int oldsize = fragP->fr_subtype;
1380
  int newsize = oldsize;
1381
  op_type_T optype;
1382
   /* Index of relaxation we care about.  */
1383
  int ri;
1384
 
1385
  tprintf ("\033[36mrelax frag: addr %08lx fix %ld var %ld ofs %ld lit %p opc %p type %d sub %d str %ld\033[0m\n",
1386
           (unsigned long) (fragP->fr_address
1387
                            + (fragP->fr_opcode - fragP->fr_literal)),
1388
           (long) fragP->fr_fix, (long) fragP->fr_var, (long) fragP->fr_offset,
1389
           fragP->fr_literal, fragP->fr_opcode, fragP->fr_type, fragP->fr_subtype, stretch);
1390
 
1391
  optype = rx_opcode_type (fragP->fr_opcode);
1392
 
1393
  /* In the one case where we have both a disp and imm relaxation, we want
1394
     the imm relaxation here.  */
1395
  ri = 0;
1396
  if (fragP->tc_frag_data->n_relax > 1
1397
      && fragP->tc_frag_data->relax[0].type == RX_RELAX_DISP)
1398
    ri = 1;
1399
 
1400
  /* Try to get the target address.  */
1401
  if (rx_frag_fix_value (fragP, segment, ri, & addr0,
1402
                         fragP->tc_frag_data->relax[ri].type != RX_RELAX_BRANCH,
1403
                         & sym_addr))
1404
    {
1405
      /* If we don't, we must use the maximum size for the linker.
1406
         Note that we don't use synthetically expanded conditionals
1407
         for this.  */
1408
      switch (fragP->tc_frag_data->relax[ri].type)
1409
        {
1410
        case RX_RELAX_BRANCH:
1411
          switch (optype)
1412
            {
1413
            case OT_bra:
1414
            case OT_bsr:
1415
              newsize = 4;
1416
              break;
1417
            case OT_beq:
1418
            case OT_bne:
1419
              newsize = 3;
1420
              break;
1421
            case OT_bcc:
1422
              newsize = 2;
1423
              break;
1424
            case OT_other:
1425
              newsize = oldsize;
1426
              break;
1427
            }
1428
          break;
1429
 
1430
        case RX_RELAX_IMM:
1431
          newsize = fragP->tc_frag_data->relax[ri].val_ofs + 4;
1432
          break;
1433
        }
1434
      fragP->fr_subtype = newsize;
1435
      tprintf (" -> new %d old %d delta %d (external)\n", newsize, oldsize, newsize-oldsize);
1436
      return newsize - oldsize;
1437
    }
1438
 
1439
  mypc = fragP->fr_address + (fragP->fr_opcode - fragP->fr_literal);
1440
  if (sym_addr > mypc)
1441
    addr0 += stretch;
1442
 
1443
  switch (fragP->tc_frag_data->relax[ri].type)
1444
    {
1445
    case  RX_RELAX_BRANCH:
1446
      tprintf ("branch, addr %08lx pc %08lx disp %ld\n",
1447
               (unsigned long) addr0, (unsigned long) mypc,
1448
               (long) (addr0 - mypc));
1449
      disp = (int) addr0 - (int) mypc;
1450
 
1451
      switch (optype)
1452
        {
1453
        case OT_bcc:
1454
          if (disp >= -128 && (disp - (oldsize-2)) <= 127)
1455
            /* bcc.b */
1456
            newsize = 2;
1457
          else if (disp >= -32768 && (disp - (oldsize-5)) <= 32767)
1458
            /* bncc.b/bra.w */
1459
            newsize = 5;
1460
          else
1461
            /* bncc.b/bra.a */
1462
            newsize = 6;
1463
          break;
1464
 
1465
        case OT_beq:
1466
        case OT_bne:
1467
          if ((disp - (oldsize-1)) >= 3 && (disp - (oldsize-1)) <= 10 && !linkrelax)
1468
            /* beq.s */
1469
            newsize = 1;
1470
          else if (disp >= -128 && (disp - (oldsize-2)) <= 127)
1471
            /* beq.b */
1472
            newsize = 2;
1473
          else if (disp >= -32768 && (disp - (oldsize-3)) <= 32767)
1474
            /* beq.w */
1475
            newsize = 3;
1476
          else
1477
            /* bne.s/bra.a */
1478
            newsize = 5;
1479
          break;
1480
 
1481
        case OT_bra:
1482
        case OT_bsr:
1483
          if ((disp - (oldsize-1)) >= 3 && (disp - (oldsize-1)) <= 10 && !linkrelax)
1484
            /* bra.s */
1485
            newsize = 1;
1486
          else if (disp >= -128 && (disp - (oldsize-2)) <= 127)
1487
            /* bra.b */
1488
            newsize = 2;
1489
          else if (disp >= -32768 && (disp - (oldsize-3)) <= 32767)
1490
            /* bra.w */
1491
            newsize = 3;
1492
          else
1493
            /* bra.a */
1494
            newsize = 4;
1495
          break;
1496
 
1497
        case OT_other:
1498
          break;
1499
        }
1500
      tprintf (" - newsize %d\n", newsize);
1501
      break;
1502
 
1503
    case RX_RELAX_IMM:
1504
      tprintf ("other, addr %08lx pc %08lx LI %d OF %d\n",
1505
               (unsigned long) addr0, (unsigned long) mypc,
1506
               fragP->tc_frag_data->relax[ri].field_pos,
1507
               fragP->tc_frag_data->relax[ri].val_ofs);
1508
 
1509
      newsize = fragP->tc_frag_data->relax[ri].val_ofs;
1510
 
1511
      if ((long) addr0 >= -128 && (long) addr0 <= 127)
1512
        newsize += 1;
1513
      else if ((long) addr0 >= -32768 && (long) addr0 <= 32767)
1514
        newsize += 2;
1515
      else if ((long) addr0 >= -8388608 && (long) addr0 <= 8388607)
1516
        newsize += 3;
1517
      else
1518
        newsize += 4;
1519
      break;
1520
 
1521
    default:
1522
      break;
1523
    }
1524
 
1525
  if (fragP->tc_frag_data->relax[ri].type == RX_RELAX_BRANCH)
1526
    switch (optype)
1527
      {
1528
      case OT_bra:
1529
      case OT_bcc:
1530
      case OT_beq:
1531
      case OT_bne:
1532
        break;
1533
      case OT_bsr:
1534
        if (newsize < 3)
1535
          newsize = 3;
1536
        break;
1537
      case OT_other:
1538
        break;
1539
      }
1540
 
1541
  /* This prevents infinite loops in align-heavy sources.  */
1542
  if (newsize < oldsize)
1543
    {
1544
      if (fragP->tc_frag_data->times_shrank > 10
1545
         && fragP->tc_frag_data->times_grown > 10)
1546
       newsize = oldsize;
1547
      if (fragP->tc_frag_data->times_shrank < 20)
1548
       fragP->tc_frag_data->times_shrank ++;
1549
    }
1550
  else if (newsize > oldsize)
1551
    {
1552
      if (fragP->tc_frag_data->times_grown < 20)
1553
       fragP->tc_frag_data->times_grown ++;
1554
    }
1555
 
1556
  fragP->fr_subtype = newsize;
1557
  tprintf (" -> new %d old %d delta %d\n", newsize, oldsize, newsize-oldsize);
1558
  return newsize - oldsize;
1559
}
1560
 
1561
/* This lets us test for the opcode type and the desired size in a
1562
   switch statement.  */
1563
#define OPCODE(type,size) ((type) * 16 + (size))
1564
 
1565
/* Given the opcode stored in fr_opcode and the number of bytes we
1566
   think we need, encode a new opcode.  We stored a pointer to the
1567
   fixup for this opcode in the tc_frag_data structure.  If we can do
1568
   the fixup here, we change the relocation type to "none" (we test
1569
   for that in tc_gen_reloc) else we change it to the right type for
1570
   the new (biggest) opcode.  */
1571
 
1572
void
1573
md_convert_frag (bfd *   abfd ATTRIBUTE_UNUSED,
1574
                 segT    segment ATTRIBUTE_UNUSED,
1575
                 fragS * fragP ATTRIBUTE_UNUSED)
1576
{
1577
  rx_bytesT * rxb = fragP->tc_frag_data;
1578
  addressT addr0, mypc;
1579
  int disp;
1580
  int reloc_type, reloc_adjust;
1581
  char * op = fragP->fr_opcode;
1582
  int keep_reloc = 0;
1583
  int ri;
1584
  int fi = (rxb->n_fixups > 1) ? 1 : 0;
1585
  fixS * fix = rxb->fixups[fi].fixP;
1586
 
1587
  tprintf ("\033[31mconvrt frag: addr %08lx fix %ld var %ld ofs %ld lit %p opc %p type %d sub %d\033[0m\n",
1588
           (unsigned long) (fragP->fr_address
1589
                            + (fragP->fr_opcode - fragP->fr_literal)),
1590
           (long) fragP->fr_fix, (long) fragP->fr_var, (long) fragP->fr_offset,
1591
           fragP->fr_literal, fragP->fr_opcode, fragP->fr_type,
1592
           fragP->fr_subtype);
1593
 
1594
#if TRACE_RELAX
1595
  {
1596
    int i;
1597
 
1598
    printf ("lit %08x opc %08x", (int) fragP->fr_literal, (int) fragP->fr_opcode);
1599
    for (i = 0; i < 10; i++)
1600
      printf (" %02x", (unsigned char) (fragP->fr_opcode[i]));
1601
    printf ("\n");
1602
  }
1603
#endif
1604
 
1605
  /* In the one case where we have both a disp and imm relaxation, we want
1606
     the imm relaxation here.  */
1607
  ri = 0;
1608
  if (fragP->tc_frag_data->n_relax > 1
1609
      && fragP->tc_frag_data->relax[0].type == RX_RELAX_DISP)
1610
    ri = 1;
1611
 
1612
  /* We used a new frag for this opcode, so the opcode address should
1613
     be the frag address.  */
1614
  mypc = fragP->fr_address + (fragP->fr_opcode - fragP->fr_literal);
1615
 
1616
  /* Try to get the target address.  If we fail here, we just use the
1617
     largest format.  */
1618
  if (rx_frag_fix_value (fragP, segment, 0, & addr0,
1619
                         fragP->tc_frag_data->relax[ri].type != RX_RELAX_BRANCH, 0))
1620
    {
1621
      /* We don't know the target address.  */
1622
      keep_reloc = 1;
1623
      addr0 = 0;
1624
      disp = 0;
1625
    }
1626
  else
1627
    {
1628
      /* We know the target address, and it's in addr0.  */
1629
      disp = (int) addr0 - (int) mypc;
1630
    }
1631
 
1632
  if (linkrelax)
1633
    keep_reloc = 1;
1634
 
1635
  reloc_type = BFD_RELOC_NONE;
1636
  reloc_adjust = 0;
1637
 
1638
  tprintf ("convert, op is %d, disp %d (%lx-%lx)\n",
1639
           rx_opcode_type (fragP->fr_opcode), disp,
1640
           (unsigned long) addr0, (unsigned long) mypc);
1641
  switch (fragP->tc_frag_data->relax[ri].type)
1642
    {
1643
    case RX_RELAX_BRANCH:
1644
      switch (OPCODE (rx_opcode_type (fragP->fr_opcode), fragP->fr_subtype))
1645
        {
1646
        case OPCODE (OT_bra, 1): /* BRA.S - no change.  */
1647
          op[0] = 0x08 + (disp & 7);
1648
          break;
1649
        case OPCODE (OT_bra, 2): /* BRA.B - 8 bit.  */
1650
          op[0] = 0x2e;
1651
          op[1] = disp;
1652
          reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1653
          reloc_adjust = 1;
1654
          break;
1655
        case OPCODE (OT_bra, 3): /* BRA.W - 16 bit.  */
1656
          op[0] = 0x38;
1657
#if RX_OPCODE_BIG_ENDIAN
1658
          op[1] = (disp >> 8) & 0xff;
1659
          op[2] = disp;
1660
#else
1661
          op[2] = (disp >> 8) & 0xff;
1662
          op[1] = disp;
1663
#endif
1664
          reloc_adjust = 1;
1665
          reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1666
          break;
1667
        case OPCODE (OT_bra, 4): /* BRA.A - 24 bit.  */
1668
          op[0] = 0x04;
1669
#if RX_OPCODE_BIG_ENDIAN
1670
          op[1] = (disp >> 16) & 0xff;
1671
          op[2] = (disp >> 8) & 0xff;
1672
          op[3] = disp;
1673
#else
1674
          op[3] = (disp >> 16) & 0xff;
1675
          op[2] = (disp >> 8) & 0xff;
1676
          op[1] = disp;
1677
#endif
1678
          reloc_type = keep_reloc ? BFD_RELOC_24_PCREL : BFD_RELOC_NONE;
1679
          reloc_adjust = 1;
1680
          break;
1681
 
1682
        case OPCODE (OT_beq, 1): /* BEQ.S - no change.  */
1683
          op[0] = 0x10 + (disp & 7);
1684
          break;
1685
        case OPCODE (OT_beq, 2): /* BEQ.B - 8 bit.  */
1686
          op[0] = 0x20;
1687
          op[1] = disp;
1688
          reloc_adjust = 1;
1689
          reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1690
          break;
1691
        case OPCODE (OT_beq, 3): /* BEQ.W - 16 bit.  */
1692
          op[0] = 0x3a;
1693
#if RX_OPCODE_BIG_ENDIAN
1694
          op[1] = (disp >> 8) & 0xff;
1695
          op[2] = disp;
1696
#else
1697
          op[2] = (disp >> 8) & 0xff;
1698
          op[1] = disp;
1699
#endif
1700
          reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1701
          reloc_adjust = 1;
1702
          break;
1703
        case OPCODE (OT_beq, 5): /* BEQ.A - synthetic.  */
1704 160 khays
          op[0] = 0x1d; /* bne.s .+5.  */
1705 16 khays
          op[1] = 0x04; /* bra.a dsp:24.  */
1706
          disp -= 1;
1707
#if RX_OPCODE_BIG_ENDIAN
1708
          op[2] = (disp >> 16) & 0xff;
1709
          op[3] = (disp >> 8) & 0xff;
1710
          op[4] = disp;
1711
#else
1712
          op[4] = (disp >> 16) & 0xff;
1713
          op[3] = (disp >> 8) & 0xff;
1714
          op[2] = disp;
1715
#endif
1716
          reloc_type = keep_reloc ? BFD_RELOC_24_PCREL : BFD_RELOC_NONE;
1717
          reloc_adjust = 2;
1718
          break;
1719
 
1720
        case OPCODE (OT_bne, 1): /* BNE.S - no change.  */
1721
          op[0] = 0x18 + (disp & 7);
1722
          break;
1723
        case OPCODE (OT_bne, 2): /* BNE.B - 8 bit.  */
1724
          op[0] = 0x21;
1725
          op[1] = disp;
1726
          reloc_adjust = 1;
1727
          reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1728
          break;
1729
        case OPCODE (OT_bne, 3): /* BNE.W - 16 bit.  */
1730
          op[0] = 0x3b;
1731
#if RX_OPCODE_BIG_ENDIAN
1732
          op[1] = (disp >> 8) & 0xff;
1733
          op[2] = disp;
1734
#else
1735
          op[2] = (disp >> 8) & 0xff;
1736
          op[1] = disp;
1737
#endif
1738
          reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1739
          reloc_adjust = 1;
1740
          break;
1741
        case OPCODE (OT_bne, 5): /* BNE.A - synthetic.  */
1742 160 khays
          op[0] = 0x15; /* beq.s .+5.  */
1743 16 khays
          op[1] = 0x04; /* bra.a dsp:24.  */
1744
          disp -= 1;
1745
#if RX_OPCODE_BIG_ENDIAN
1746
          op[2] = (disp >> 16) & 0xff;
1747
          op[3] = (disp >> 8) & 0xff;
1748
          op[4] = disp;
1749
#else
1750
          op[4] = (disp >> 16) & 0xff;
1751
          op[3] = (disp >> 8) & 0xff;
1752
          op[2] = disp;
1753
#endif
1754
          reloc_type = keep_reloc ? BFD_RELOC_24_PCREL : BFD_RELOC_NONE;
1755
          reloc_adjust = 2;
1756
          break;
1757
 
1758
        case OPCODE (OT_bsr, 3): /* BSR.W - 16 bit.  */
1759
          op[0] = 0x39;
1760
#if RX_OPCODE_BIG_ENDIAN
1761
          op[1] = (disp >> 8) & 0xff;
1762
          op[2] = disp;
1763
#else
1764
          op[2] = (disp >> 8) & 0xff;
1765
          op[1] = disp;
1766
#endif
1767
          reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1768
          reloc_adjust = 0;
1769
          break;
1770
        case OPCODE (OT_bsr, 4): /* BSR.A - 24 bit.  */
1771
          op[0] = 0x05;
1772
#if RX_OPCODE_BIG_ENDIAN
1773
          op[1] = (disp >> 16) & 0xff;
1774
          op[2] = (disp >> 8) & 0xff;
1775
          op[3] = disp;
1776
#else
1777
          op[3] = (disp >> 16) & 0xff;
1778
          op[2] = (disp >> 8) & 0xff;
1779
          op[1] = disp;
1780
#endif
1781
          reloc_type = keep_reloc ? BFD_RELOC_24_PCREL : BFD_RELOC_NONE;
1782
          reloc_adjust = 0;
1783
          break;
1784
 
1785
        case OPCODE (OT_bcc, 2): /* Bcond.B - 8 bit.  */
1786
          op[1] = disp;
1787
          reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1788
          break;
1789
        case OPCODE (OT_bcc, 5): /* Bcond.W - synthetic.  */
1790
          op[0] ^= 1; /* Invert condition.  */
1791
          op[1] = 5;  /* Displacement.  */
1792
          op[2] = 0x38;
1793
          disp -= 2;
1794
#if RX_OPCODE_BIG_ENDIAN
1795
          op[3] = (disp >> 8) & 0xff;
1796
          op[4] = disp;
1797
#else
1798
          op[4] = (disp >> 8) & 0xff;
1799
          op[3] = disp;
1800
#endif
1801
          reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1802
          reloc_adjust = 2;
1803
          break;
1804
        case OPCODE (OT_bcc, 6): /* Bcond.S - synthetic.  */
1805
          op[0] ^= 1; /* Invert condition.  */
1806
          op[1] = 6;  /* Displacement.  */
1807
          op[2] = 0x04;
1808
          disp -= 2;
1809
#if RX_OPCODE_BIG_ENDIAN
1810
          op[3] = (disp >> 16) & 0xff;
1811
          op[4] = (disp >> 8) & 0xff;
1812
          op[5] = disp;
1813
#else
1814
          op[5] = (disp >> 16) & 0xff;
1815
          op[4] = (disp >> 8) & 0xff;
1816
          op[3] = disp;
1817
#endif
1818
          reloc_type = keep_reloc ? BFD_RELOC_24_PCREL : BFD_RELOC_NONE;
1819
          reloc_adjust = 2;
1820
          break;
1821
 
1822
        default:
1823
          /* These are opcodes we'll relax in th linker, later.  */
1824
          if (rxb->n_fixups)
1825
            reloc_type = rxb->fixups[ri].fixP->fx_r_type;
1826
          break;
1827
        }
1828
      break;
1829
 
1830
    case RX_RELAX_IMM:
1831
      {
1832
        int nbytes = fragP->fr_subtype - fragP->tc_frag_data->relax[ri].val_ofs;
1833
        int li;
1834
        char * imm = op + fragP->tc_frag_data->relax[ri].val_ofs;
1835
 
1836
        switch (nbytes)
1837
          {
1838
          case 1:
1839
            li = 1;
1840
            imm[0] = addr0;
1841
            reloc_type = BFD_RELOC_8;
1842
            break;
1843
          case 2:
1844
            li = 2;
1845
#if RX_OPCODE_BIG_ENDIAN
1846
            imm[1] = addr0;
1847
            imm[0] = addr0 >> 8;
1848
#else
1849
            imm[0] = addr0;
1850
            imm[1] = addr0 >> 8;
1851
#endif
1852
            reloc_type = BFD_RELOC_RX_16_OP;
1853
            break;
1854
          case 3:
1855
            li = 3;
1856
#if RX_OPCODE_BIG_ENDIAN
1857
            imm[2] = addr0;
1858
            imm[1] = addr0 >> 8;
1859
            imm[0] = addr0 >> 16;
1860
#else
1861
            imm[0] = addr0;
1862
            imm[1] = addr0 >> 8;
1863
            imm[2] = addr0 >> 16;
1864
#endif
1865
            reloc_type = BFD_RELOC_RX_24_OP;
1866
            break;
1867
          case 4:
1868
            li = 0;
1869
#if RX_OPCODE_BIG_ENDIAN
1870
            imm[3] = addr0;
1871
            imm[2] = addr0 >> 8;
1872
            imm[1] = addr0 >> 16;
1873
            imm[0] = addr0 >> 24;
1874
#else
1875
            imm[0] = addr0;
1876
            imm[1] = addr0 >> 8;
1877
            imm[2] = addr0 >> 16;
1878
            imm[3] = addr0 >> 24;
1879
#endif
1880
            reloc_type = BFD_RELOC_RX_32_OP;
1881
            break;
1882
          default:
1883
            as_bad (_("invalid immediate size"));
1884
            li = -1;
1885
          }
1886
 
1887
        switch (fragP->tc_frag_data->relax[ri].field_pos)
1888
          {
1889
          case 6:
1890
            op[0] &= 0xfc;
1891
            op[0] |= li;
1892
            break;
1893
          case 12:
1894
            op[1] &= 0xf3;
1895
            op[1] |= li << 2;
1896
            break;
1897
          case 20:
1898
            op[2] &= 0xf3;
1899
            op[2] |= li << 2;
1900
            break;
1901
          default:
1902
            as_bad (_("invalid immediate field position"));
1903
          }
1904
      }
1905
      break;
1906
 
1907
    default:
1908
      if (rxb->n_fixups)
1909
        {
1910
          reloc_type = fix->fx_r_type;
1911
          reloc_adjust = 0;
1912
        }
1913
      break;
1914
    }
1915
 
1916
  if (rxb->n_fixups)
1917
    {
1918
 
1919
      fix->fx_r_type = reloc_type;
1920
      fix->fx_where += reloc_adjust;
1921
      switch (reloc_type)
1922
        {
1923
        case BFD_RELOC_NONE:
1924
          fix->fx_size = 0;
1925
          break;
1926
        case BFD_RELOC_8:
1927
          fix->fx_size = 1;
1928
          break;
1929
        case BFD_RELOC_16_PCREL:
1930
        case BFD_RELOC_RX_16_OP:
1931
          fix->fx_size = 2;
1932
          break;
1933
        case BFD_RELOC_24_PCREL:
1934
        case BFD_RELOC_RX_24_OP:
1935
          fix->fx_size = 3;
1936
          break;
1937
        case BFD_RELOC_RX_32_OP:
1938
          fix->fx_size = 4;
1939
          break;
1940
        }
1941
    }
1942
 
1943
  fragP->fr_fix = fragP->fr_subtype + (fragP->fr_opcode - fragP->fr_literal);
1944
  tprintf ("fragP->fr_fix now %ld (%d + (%p - %p)\n", (long) fragP->fr_fix,
1945
          fragP->fr_subtype, fragP->fr_opcode, fragP->fr_literal);
1946
  fragP->fr_var = 0;
1947
 
1948
  if (fragP->fr_next != NULL
1949
          && ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
1950
              != fragP->fr_fix))
1951
    as_bad (_("bad frag at %p : fix %ld addr %ld %ld \n"), fragP,
1952
            (long) fragP->fr_fix,
1953
            (long) fragP->fr_address, (long) fragP->fr_next->fr_address);
1954
}
1955
 
1956
#undef OPCODE
1957
 
1958
int
1959
rx_validate_fix_sub (struct fix * f)
1960
{
1961
  /* We permit the subtraction of two symbols in a few cases.  */
1962
  /* mov #sym1-sym2, R3 */
1963
  if (f->fx_r_type == BFD_RELOC_RX_32_OP)
1964
    return 1;
1965
  /* .long sym1-sym2 */
1966
  if (f->fx_r_type == BFD_RELOC_RX_DIFF
1967
      && ! f->fx_pcrel
1968
      && (f->fx_size == 4 || f->fx_size == 2 || f->fx_size == 1))
1969
    return 1;
1970
  return 0;
1971
}
1972
 
1973
long
1974
md_pcrel_from_section (fixS * fixP, segT sec)
1975
{
1976
  long rv;
1977
 
1978
  if (fixP->fx_addsy != NULL
1979
      && (! S_IS_DEFINED (fixP->fx_addsy)
1980
          || S_GET_SEGMENT (fixP->fx_addsy) != sec))
1981
    /* The symbol is undefined (or is defined but not in this section).
1982
       Let the linker figure it out.  */
1983
    return 0;
1984
 
1985
  rv = fixP->fx_frag->fr_address + fixP->fx_where;
1986
  switch (fixP->fx_r_type)
1987
    {
1988
    case BFD_RELOC_RX_DIR3U_PCREL:
1989
      return rv;
1990
    default:
1991
      return rv - 1;
1992
    }
1993
}
1994
 
1995
void
1996
rx_cons_fix_new (fragS *        frag,
1997
                 int            where,
1998
                 int            size,
1999
                 expressionS *  exp)
2000
{
2001
  bfd_reloc_code_real_type type;
2002
 
2003
  switch (size)
2004
    {
2005
    case 1:
2006
      type = BFD_RELOC_8;
2007
      break;
2008
    case 2:
2009
      type = BFD_RELOC_16;
2010
      break;
2011
    case 3:
2012
      type = BFD_RELOC_24;
2013
      break;
2014
    case 4:
2015
      type = BFD_RELOC_32;
2016
      break;
2017
    default:
2018
      as_bad (_("unsupported constant size %d\n"), size);
2019
      return;
2020
    }
2021
 
2022
  if (exp->X_op == O_subtract && exp->X_op_symbol)
2023
    {
2024
      if (size != 4 && size != 2 && size != 1)
2025
        as_bad (_("difference of two symbols only supported with .long, .short, or .byte"));
2026
      else
2027
        type = BFD_RELOC_RX_DIFF;
2028
    }
2029
 
2030
  fix_new_exp (frag, where, (int) size, exp, 0, type);
2031
}
2032
 
2033
void
2034
md_apply_fix (struct fix * f ATTRIBUTE_UNUSED,
2035
              valueT *     t ATTRIBUTE_UNUSED,
2036
              segT         s ATTRIBUTE_UNUSED)
2037
{
2038
  /* Instruction bytes are always little endian.  */
2039
  char * op;
2040
  unsigned long val;
2041
 
2042
  if (f->fx_addsy && S_FORCE_RELOC (f->fx_addsy, 1))
2043
    return;
2044
  if (f->fx_subsy && S_FORCE_RELOC (f->fx_subsy, 1))
2045
    return;
2046
 
2047
#define OP2(x) op[target_big_endian ? 1-x : x]
2048
#define OP3(x) op[target_big_endian ? 2-x : x]
2049
#define OP4(x) op[target_big_endian ? 3-x : x]
2050
 
2051
  op = f->fx_frag->fr_literal + f->fx_where;
2052
  val = (unsigned long) * t;
2053
 
2054
  /* Opcode words are always the same endian.  Data words are either
2055
     big or little endian.  */
2056
 
2057
  switch (f->fx_r_type)
2058
    {
2059
    case BFD_RELOC_NONE:
2060
      break;
2061
 
2062
    case BFD_RELOC_RX_RELAX:
2063
      f->fx_done = 1;
2064
      break;
2065
 
2066
    case BFD_RELOC_RX_DIR3U_PCREL:
2067
      if (val < 3 || val > 10)
2068
        as_bad_where (f->fx_file, f->fx_line,
2069
                      _("jump not 3..10 bytes away (is %d)"), (int) val);
2070
      op[0] &= 0xf8;
2071
      op[0] |= val & 0x07;
2072
      break;
2073
 
2074
    case BFD_RELOC_8:
2075
    case BFD_RELOC_8_PCREL:
2076
    case BFD_RELOC_RX_8U:
2077
      op[0] = val;
2078
      break;
2079
 
2080
    case BFD_RELOC_16:
2081
      OP2(1) = val & 0xff;
2082
      OP2(0) = (val >> 8) & 0xff;
2083
      break;
2084
 
2085
    case BFD_RELOC_16_PCREL:
2086
    case BFD_RELOC_RX_16_OP:
2087
    case BFD_RELOC_RX_16U:
2088
#if RX_OPCODE_BIG_ENDIAN
2089
      op[1] = val & 0xff;
2090
      op[0] = (val >> 8) & 0xff;
2091
#else
2092
      op[0] = val & 0xff;
2093
      op[1] = (val >> 8) & 0xff;
2094
#endif
2095
      break;
2096
 
2097
    case BFD_RELOC_24:
2098
      OP3(0) = val & 0xff;
2099
      OP3(1) = (val >> 8) & 0xff;
2100
      OP3(2) = (val >> 16) & 0xff;
2101
      break;
2102
 
2103
    case BFD_RELOC_24_PCREL:
2104
    case BFD_RELOC_RX_24_OP:
2105
    case BFD_RELOC_RX_24U:
2106
#if RX_OPCODE_BIG_ENDIAN
2107
      op[2] = val & 0xff;
2108
      op[1] = (val >> 8) & 0xff;
2109
      op[0] = (val >> 16) & 0xff;
2110
#else
2111
      op[0] = val & 0xff;
2112
      op[1] = (val >> 8) & 0xff;
2113
      op[2] = (val >> 16) & 0xff;
2114
#endif
2115
      break;
2116
 
2117
    case BFD_RELOC_RX_DIFF:
2118
      switch (f->fx_size)
2119
        {
2120
        case 1:
2121
          op[0] = val & 0xff;
2122
          break;
2123
        case 2:
2124
          OP2(0) = val & 0xff;
2125
          OP2(1) = (val >> 8) & 0xff;
2126
          break;
2127
        case 4:
2128
          OP4(0) = val & 0xff;
2129
          OP4(1) = (val >> 8) & 0xff;
2130
          OP4(2) = (val >> 16) & 0xff;
2131
          OP4(3) = (val >> 24) & 0xff;
2132
          break;
2133
        }
2134
      break;
2135
 
2136
    case BFD_RELOC_32:
2137
      OP4(0) = val & 0xff;
2138
      OP4(1) = (val >> 8) & 0xff;
2139
      OP4(2) = (val >> 16) & 0xff;
2140
      OP4(3) = (val >> 24) & 0xff;
2141
      break;
2142
 
2143
    case BFD_RELOC_RX_32_OP:
2144
#if RX_OPCODE_BIG_ENDIAN
2145
      op[3] = val & 0xff;
2146
      op[2] = (val >> 8) & 0xff;
2147
      op[1] = (val >> 16) & 0xff;
2148
      op[0] = (val >> 24) & 0xff;
2149
#else
2150
      op[0] = val & 0xff;
2151
      op[1] = (val >> 8) & 0xff;
2152
      op[2] = (val >> 16) & 0xff;
2153
      op[3] = (val >> 24) & 0xff;
2154
#endif
2155
      break;
2156
 
2157
    case BFD_RELOC_RX_NEG8:
2158
      op[0] = - val;
2159
      break;
2160
 
2161
    case BFD_RELOC_RX_NEG16:
2162
      val = -val;
2163
#if RX_OPCODE_BIG_ENDIAN
2164
      op[1] = val & 0xff;
2165
      op[0] = (val >> 8) & 0xff;
2166
#else
2167
      op[0] = val & 0xff;
2168
      op[1] = (val >> 8) & 0xff;
2169
#endif
2170
      break;
2171
 
2172
    case BFD_RELOC_RX_NEG24:
2173
      val = -val;
2174
#if RX_OPCODE_BIG_ENDIAN
2175
      op[2] = val & 0xff;
2176
      op[1] = (val >> 8) & 0xff;
2177
      op[0] = (val >> 16) & 0xff;
2178
#else
2179
      op[0] = val & 0xff;
2180
      op[1] = (val >> 8) & 0xff;
2181
      op[2] = (val >> 16) & 0xff;
2182
#endif
2183
      break;
2184
 
2185
    case BFD_RELOC_RX_NEG32:
2186
      val = -val;
2187
#if RX_OPCODE_BIG_ENDIAN
2188
      op[3] = val & 0xff;
2189
      op[2] = (val >> 8) & 0xff;
2190
      op[1] = (val >> 16) & 0xff;
2191
      op[0] = (val >> 24) & 0xff;
2192
#else
2193
      op[0] = val & 0xff;
2194
      op[1] = (val >> 8) & 0xff;
2195
      op[2] = (val >> 16) & 0xff;
2196
      op[3] = (val >> 24) & 0xff;
2197
#endif
2198
      break;
2199
 
2200
    case BFD_RELOC_RX_GPRELL:
2201
      val >>= 1;
2202
    case BFD_RELOC_RX_GPRELW:
2203
      val >>= 1;
2204
    case BFD_RELOC_RX_GPRELB:
2205
#if RX_OPCODE_BIG_ENDIAN
2206
      op[1] = val & 0xff;
2207
      op[0] = (val >> 8) & 0xff;
2208
#else
2209
      op[0] = val & 0xff;
2210
      op[1] = (val >> 8) & 0xff;
2211
#endif
2212
      break;
2213
 
2214
    default:
2215
      as_bad (_("Unknown reloc in md_apply_fix: %s"),
2216
              bfd_get_reloc_code_name (f->fx_r_type));
2217
      break;
2218
    }
2219
 
2220
  if (f->fx_addsy == NULL)
2221
    f->fx_done = 1;
2222
}
2223
 
2224
arelent **
2225
tc_gen_reloc (asection * seg ATTRIBUTE_UNUSED, fixS * fixp)
2226
{
2227
  static arelent * reloc[5];
2228
  int is_opcode = 0;
2229
 
2230
  if (fixp->fx_r_type == BFD_RELOC_NONE)
2231
    {
2232
      reloc[0] = NULL;
2233
      return reloc;
2234
    }
2235
 
2236
  if (fixp->fx_subsy
2237
      && S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
2238
    {
2239
      fixp->fx_offset -= S_GET_VALUE (fixp->fx_subsy);
2240
      fixp->fx_subsy = NULL;
2241
    }
2242
 
2243
  reloc[0]                 = (arelent *) xmalloc (sizeof (arelent));
2244
  reloc[0]->sym_ptr_ptr   = (asymbol **) xmalloc (sizeof (asymbol *));
2245
  * reloc[0]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2246
  reloc[0]->address       = fixp->fx_frag->fr_address + fixp->fx_where;
2247
  reloc[0]->addend        = fixp->fx_offset;
2248
 
2249
  if (fixp->fx_r_type == BFD_RELOC_RX_32_OP
2250
      && fixp->fx_subsy)
2251
    {
2252
      fixp->fx_r_type = BFD_RELOC_RX_DIFF;
2253
      is_opcode = 1;
2254
    }
2255
 
2256
  /* Certain BFD relocations cannot be translated directly into
2257
     a single (non-Red Hat) RX relocation, but instead need
2258
     multiple RX relocations - handle them here.  */
2259
  switch (fixp->fx_r_type)
2260
    {
2261
    case BFD_RELOC_RX_DIFF:
2262
      reloc[0]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2263
 
2264
      reloc[1]                = (arelent *) xmalloc (sizeof (arelent));
2265
      reloc[1]->sym_ptr_ptr   = (asymbol **) xmalloc (sizeof (asymbol *));
2266
      * reloc[1]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_subsy);
2267
      reloc[1]->address       = fixp->fx_frag->fr_address + fixp->fx_where;
2268
      reloc[1]->addend        = 0;
2269
      reloc[1]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2270
 
2271
      reloc[2]                = (arelent *) xmalloc (sizeof (arelent));
2272
      reloc[2]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_OP_SUBTRACT);
2273
      reloc[2]->addend        = 0;
2274
      reloc[2]->sym_ptr_ptr   = reloc[1]->sym_ptr_ptr;
2275
      reloc[2]->address       = fixp->fx_frag->fr_address + fixp->fx_where;
2276
 
2277
      reloc[3]                = (arelent *) xmalloc (sizeof (arelent));
2278
      switch (fixp->fx_size)
2279
        {
2280
        case 1:
2281
          reloc[3]->howto   = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS8);
2282
          break;
2283
        case 2:
2284
          if (!is_opcode && target_big_endian)
2285
            reloc[3]->howto   = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS16_REV);
2286
          else
2287
            reloc[3]->howto   = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS16);
2288
          break;
2289
        case 4:
2290
          if (!is_opcode && target_big_endian)
2291
            reloc[3]->howto   = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS32_REV);
2292
          else
2293
            reloc[3]->howto   = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS32);
2294
          break;
2295
        }
2296
      reloc[3]->addend      = 0;
2297
      reloc[3]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2298
      reloc[3]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2299
 
2300
      reloc[4] = NULL;
2301
      break;
2302
 
2303
    case BFD_RELOC_RX_GPRELL:
2304
      reloc[0]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2305
 
2306
      reloc[1]                = (arelent *) xmalloc (sizeof (arelent));
2307
      reloc[1]->sym_ptr_ptr   = (asymbol **) xmalloc (sizeof (asymbol *));
2308
      if (gp_symbol == NULL)
2309
        {
2310
          if (symbol_table_frozen)
2311
            {
2312
              symbolS * gp;
2313
 
2314
              gp = symbol_find ("__gp");
2315
              if (gp == NULL)
2316
                as_bad (("unable to create __gp symbol: please re-assemble with the -msmall-data-limit option specified"));
2317
              else
2318
                gp_symbol = symbol_get_bfdsym (gp);
2319
            }
2320
          else
2321
            gp_symbol = symbol_get_bfdsym (symbol_find_or_make ("__gp"));
2322
        }
2323
      * reloc[1]->sym_ptr_ptr = gp_symbol;
2324
      reloc[1]->address       = fixp->fx_frag->fr_address + fixp->fx_where;
2325
      reloc[1]->addend        = 0;
2326
      reloc[1]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2327
 
2328
      reloc[2]              = (arelent *) xmalloc (sizeof (arelent));
2329
      reloc[2]->howto       = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_OP_SUBTRACT);
2330
      reloc[2]->addend      = 0;
2331
      reloc[2]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2332
      reloc[2]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2333
 
2334
      reloc[3]              = (arelent *) xmalloc (sizeof (arelent));
2335
      reloc[3]->howto       = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS16UL);
2336
      reloc[3]->addend      = 0;
2337
      reloc[3]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2338
      reloc[3]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2339
 
2340
      reloc[4] = NULL;
2341
      break;
2342
 
2343
    case BFD_RELOC_RX_GPRELW:
2344
      reloc[0]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2345
 
2346
      reloc[1]                = (arelent *) xmalloc (sizeof (arelent));
2347
      reloc[1]->sym_ptr_ptr   = (asymbol **) xmalloc (sizeof (asymbol *));
2348
      if (gp_symbol == NULL)
2349
        {
2350
          if (symbol_table_frozen)
2351
            {
2352
              symbolS * gp;
2353
 
2354
              gp = symbol_find ("__gp");
2355
              if (gp == NULL)
2356
                as_bad (("unable to create __gp symbol: please re-assemble with the -msmall-data-limit option specified"));
2357
              else
2358
                gp_symbol = symbol_get_bfdsym (gp);
2359
            }
2360
          else
2361
            gp_symbol = symbol_get_bfdsym (symbol_find_or_make ("__gp"));
2362
        }
2363
      * reloc[1]->sym_ptr_ptr = gp_symbol;
2364
      reloc[1]->address       = fixp->fx_frag->fr_address + fixp->fx_where;
2365
      reloc[1]->addend        = 0;
2366
      reloc[1]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2367
 
2368
      reloc[2]              = (arelent *) xmalloc (sizeof (arelent));
2369
      reloc[2]->howto       = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_OP_SUBTRACT);
2370
      reloc[2]->addend      = 0;
2371
      reloc[2]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2372
      reloc[2]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2373
 
2374
      reloc[3]              = (arelent *) xmalloc (sizeof (arelent));
2375
      reloc[3]->howto       = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS16UW);
2376
      reloc[3]->addend      = 0;
2377
      reloc[3]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2378
      reloc[3]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2379
 
2380
      reloc[4] = NULL;
2381
      break;
2382
 
2383
    case BFD_RELOC_RX_GPRELB:
2384
      reloc[0]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2385
 
2386
      reloc[1]                = (arelent *) xmalloc (sizeof (arelent));
2387
      reloc[1]->sym_ptr_ptr   = (asymbol **) xmalloc (sizeof (asymbol *));
2388
      if (gp_symbol == NULL)
2389
        {
2390
          if (symbol_table_frozen)
2391
            {
2392
              symbolS * gp;
2393
 
2394
              gp = symbol_find ("__gp");
2395
              if (gp == NULL)
2396
                as_bad (("unable to create __gp symbol: please re-assemble with the -msmall-data-limit option specified"));
2397
              else
2398
                gp_symbol = symbol_get_bfdsym (gp);
2399
            }
2400
          else
2401
            gp_symbol = symbol_get_bfdsym (symbol_find_or_make ("__gp"));
2402
        }
2403
      * reloc[1]->sym_ptr_ptr = gp_symbol;
2404
      reloc[1]->address       = fixp->fx_frag->fr_address + fixp->fx_where;
2405
      reloc[1]->addend        = 0;
2406
      reloc[1]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2407
 
2408
      reloc[2]              = (arelent *) xmalloc (sizeof (arelent));
2409
      reloc[2]->howto       = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_OP_SUBTRACT);
2410
      reloc[2]->addend      = 0;
2411
      reloc[2]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2412
      reloc[2]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2413
 
2414
      reloc[3]              = (arelent *) xmalloc (sizeof (arelent));
2415
      reloc[3]->howto       = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS16U);
2416
      reloc[3]->addend      = 0;
2417
      reloc[3]->sym_ptr_ptr = reloc[1]->sym_ptr_ptr;
2418
      reloc[3]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2419
 
2420
      reloc[4] = NULL;
2421
      break;
2422
 
2423
    case BFD_RELOC_RX_NEG32:
2424
      reloc[0]->howto         = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_SYM);
2425
 
2426
      reloc[1]              = (arelent *) xmalloc (sizeof (arelent));
2427
      reloc[1]->howto       = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_OP_NEG);
2428
      reloc[1]->addend      = 0;
2429
      reloc[1]->sym_ptr_ptr = reloc[0]->sym_ptr_ptr;
2430
      reloc[1]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2431
 
2432
      reloc[2]              = (arelent *) xmalloc (sizeof (arelent));
2433
      reloc[2]->howto       = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RX_ABS32);
2434
      reloc[2]->addend      = 0;
2435
      reloc[2]->sym_ptr_ptr = reloc[0]->sym_ptr_ptr;
2436
      reloc[2]->address     = fixp->fx_frag->fr_address + fixp->fx_where;
2437
 
2438
      reloc[3] = NULL;
2439
      break;
2440
 
2441
    default:
2442
      reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
2443
      reloc[1] = NULL;
2444
      break;
2445
    }
2446
 
2447
  return reloc;
2448
}
2449
 
2450
/* Set the ELF specific flags.  */
2451
 
2452
void
2453
rx_elf_final_processing (void)
2454
{
2455
  elf_elfheader (stdoutput)->e_flags |= elf_flags;
2456
}
2457
 
2458
/* Scan the current input line for occurances of Renesas
2459
   local labels and replace them with the GAS version.  */
2460
 
2461
void
2462
rx_start_line (void)
2463
{
2464
  int in_double_quote = 0;
2465
  int in_single_quote = 0;
2466
  int done = 0;
2467
  char * p = input_line_pointer;
2468
 
2469
  /* Scan the line looking for question marks.  Skip past quote enclosed regions.  */
2470
  do
2471
    {
2472
      switch (*p)
2473
        {
2474
        case '\n':
2475
        case 0:
2476
          done = 1;
2477
          break;
2478
 
2479
        case '"':
2480
          in_double_quote = ! in_double_quote;
2481
          break;
2482
 
2483
        case '\'':
2484
          in_single_quote = ! in_single_quote;
2485
          break;
2486
 
2487
        case '?':
2488
          if (in_double_quote || in_single_quote)
2489
            break;
2490
 
2491
          if (p[1] == ':')
2492
            *p = '1';
2493
          else if (p[1] == '+')
2494
            {
2495
              p[0] = '1';
2496
              p[1] = 'f';
2497
            }
2498
          else if (p[1] == '-')
2499
            {
2500
              p[0] = '1';
2501
              p[1] = 'b';
2502
            }
2503
          break;
2504
 
2505
        default:
2506
          break;
2507
        }
2508
 
2509
      p ++;
2510
    }
2511
  while (! done);
2512
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.