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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [config/] [frv/] [predicates.md] - Blame information for rev 816

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
;; Predicate definitions for Frv.
2
;; Copyright (C) 2005, 2007 Free Software Foundation, Inc.
3
;;
4
;; This file is part of GCC.
5
;;
6
;; GCC is free software; you can redistribute it and/or modify
7
;; it under the terms of the GNU General Public License as published by
8
;; the Free Software Foundation; either version 3, or (at your option)
9
;; any later version.
10
;;
11
;; GCC is distributed in the hope that it will be useful,
12
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
13
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
;; GNU General Public License for more details.
15
;;
16
;; You should have received a copy of the GNU General Public License
17
;; along with GCC; see the file COPYING3.  If not see
18
;; .
19
 
20
;; Return true if operand is a GPR register.
21
 
22
(define_predicate "integer_register_operand"
23
  (match_code "reg,subreg")
24
{
25
  if (GET_MODE (op) != mode && mode != VOIDmode)
26
    return FALSE;
27
 
28
  if (GET_CODE (op) == SUBREG)
29
    {
30
      if (GET_CODE (SUBREG_REG (op)) != REG)
31
        return register_operand (op, mode);
32
 
33
      op = SUBREG_REG (op);
34
    }
35
 
36
  if (GET_CODE (op) != REG)
37
    return FALSE;
38
 
39
  return GPR_AP_OR_PSEUDO_P (REGNO (op));
40
})
41
 
42
;; Return 1 is OP is a memory operand, or will be turned into one by
43
;; reload.
44
 
45
(define_predicate "frv_load_operand"
46
  (match_code "reg,subreg,mem")
47
{
48
  if (GET_MODE (op) != mode && mode != VOIDmode)
49
    return FALSE;
50
 
51
  if (reload_in_progress)
52
    {
53
      rtx tmp = op;
54
      if (GET_CODE (tmp) == SUBREG)
55
        tmp = SUBREG_REG (tmp);
56
      if (GET_CODE (tmp) == REG
57
          && REGNO (tmp) >= FIRST_PSEUDO_REGISTER)
58
        op = reg_equiv_memory_loc[REGNO (tmp)];
59
    }
60
 
61
  return op && memory_operand (op, mode);
62
})
63
 
64
;; Return true if operand is a GPR register.  Do not allow SUBREG's
65
;; here, in order to prevent a combine bug.
66
 
67
(define_predicate "gpr_no_subreg_operand"
68
  (match_code "reg")
69
{
70
  if (GET_MODE (op) != mode && mode != VOIDmode)
71
    return FALSE;
72
 
73
  if (GET_CODE (op) != REG)
74
    return FALSE;
75
 
76
  return GPR_OR_PSEUDO_P (REGNO (op));
77
})
78
 
79
;; Return 1 if operand is a GPR register or a FPR register.
80
 
81
(define_predicate "gpr_or_fpr_operand"
82
  (match_code "reg,subreg")
83
{
84
  int regno;
85
 
86
  if (GET_MODE (op) != mode && mode != VOIDmode)
87
    return FALSE;
88
 
89
  if (GET_CODE (op) == SUBREG)
90
    {
91
      if (GET_CODE (SUBREG_REG (op)) != REG)
92
        return register_operand (op, mode);
93
 
94
      op = SUBREG_REG (op);
95
    }
96
 
97
  if (GET_CODE (op) != REG)
98
    return FALSE;
99
 
100
  regno = REGNO (op);
101
  if (GPR_P (regno) || FPR_P (regno) || regno >= FIRST_PSEUDO_REGISTER)
102
    return TRUE;
103
 
104
  return FALSE;
105
})
106
 
107
;; Return 1 if operand is a GPR register or 12 bit signed immediate.
108
 
109
(define_predicate "gpr_or_int12_operand"
110
  (match_code "reg,subreg,const_int,const")
111
{
112
  if (GET_CODE (op) == CONST_INT)
113
    return IN_RANGE_P (INTVAL (op), -2048, 2047);
114
 
115
  if (got12_operand (op, mode))
116
    return true;
117
 
118
  if (GET_MODE (op) != mode && mode != VOIDmode)
119
    return FALSE;
120
 
121
  if (GET_CODE (op) == SUBREG)
122
    {
123
      if (GET_CODE (SUBREG_REG (op)) != REG)
124
        return register_operand (op, mode);
125
 
126
      op = SUBREG_REG (op);
127
    }
128
 
129
  if (GET_CODE (op) != REG)
130
    return FALSE;
131
 
132
  return GPR_OR_PSEUDO_P (REGNO (op));
133
})
134
 
135
;; Return 1 if operand is a GPR register, or a FPR register, or a 12
136
;; bit signed immediate.
137
 
138
(define_predicate "gpr_fpr_or_int12_operand"
139
  (match_code "reg,subreg,const_int")
140
{
141
  int regno;
142
 
143
  if (GET_CODE (op) == CONST_INT)
144
    return IN_RANGE_P (INTVAL (op), -2048, 2047);
145
 
146
  if (GET_MODE (op) != mode && mode != VOIDmode)
147
    return FALSE;
148
 
149
  if (GET_CODE (op) == SUBREG)
150
    {
151
      if (GET_CODE (SUBREG_REG (op)) != REG)
152
        return register_operand (op, mode);
153
 
154
      op = SUBREG_REG (op);
155
    }
156
 
157
  if (GET_CODE (op) != REG)
158
    return FALSE;
159
 
160
  regno = REGNO (op);
161
  if (GPR_P (regno) || FPR_P (regno) || regno >= FIRST_PSEUDO_REGISTER)
162
    return TRUE;
163
 
164
  return FALSE;
165
})
166
 
167
;; Return 1 if operand is a register or 10 bit signed immediate.
168
 
169
(define_predicate "gpr_or_int10_operand"
170
  (match_code "reg,subreg,const_int")
171
{
172
  if (GET_CODE (op) == CONST_INT)
173
    return IN_RANGE_P (INTVAL (op), -512, 511);
174
 
175
  if (GET_MODE (op) != mode && mode != VOIDmode)
176
    return FALSE;
177
 
178
  if (GET_CODE (op) == SUBREG)
179
    {
180
      if (GET_CODE (SUBREG_REG (op)) != REG)
181
        return register_operand (op, mode);
182
 
183
      op = SUBREG_REG (op);
184
    }
185
 
186
  if (GET_CODE (op) != REG)
187
    return FALSE;
188
 
189
  return GPR_OR_PSEUDO_P (REGNO (op));
190
})
191
 
192
;; Return 1 if operand is a register or an integer immediate.
193
 
194
(define_predicate "gpr_or_int_operand"
195
  (match_code "reg,subreg,const_int")
196
{
197
  if (GET_CODE (op) == CONST_INT)
198
    return TRUE;
199
 
200
  if (GET_MODE (op) != mode && mode != VOIDmode)
201
    return FALSE;
202
 
203
  if (GET_CODE (op) == SUBREG)
204
    {
205
      if (GET_CODE (SUBREG_REG (op)) != REG)
206
        return register_operand (op, mode);
207
 
208
      op = SUBREG_REG (op);
209
    }
210
 
211
  if (GET_CODE (op) != REG)
212
    return FALSE;
213
 
214
  return GPR_OR_PSEUDO_P (REGNO (op));
215
})
216
 
217
;; Return true if operand is something that can be an input for a move
218
;; operation.
219
 
220
(define_predicate "move_source_operand"
221
  (match_code "reg,subreg,const_int,mem,const_double,const,symbol_ref,label_ref")
222
{
223
  rtx subreg;
224
  enum rtx_code code;
225
 
226
  switch (GET_CODE (op))
227
    {
228
    default:
229
      break;
230
 
231
    case CONST_INT:
232
    case CONST_DOUBLE:
233
      return immediate_operand (op, mode);
234
 
235
    case SUBREG:
236
      if (GET_MODE (op) != mode && mode != VOIDmode)
237
        return FALSE;
238
 
239
      subreg = SUBREG_REG (op);
240
      code = GET_CODE (subreg);
241
      if (code == MEM)
242
        return frv_legitimate_address_p (mode, XEXP (subreg, 0),
243
                                         reload_completed, FALSE, FALSE);
244
 
245
      return (code == REG);
246
 
247
    case REG:
248
      if (GET_MODE (op) != mode && mode != VOIDmode)
249
        return FALSE;
250
 
251
      return TRUE;
252
 
253
    case MEM:
254
      return frv_legitimate_memory_operand (op, mode, FALSE);
255
    }
256
 
257
  return FALSE;
258
})
259
 
260
;; Return true if operand is something that can be an output for a
261
;; move operation.
262
 
263
(define_predicate "move_destination_operand"
264
  (match_code "reg,subreg,mem")
265
{
266
  rtx subreg;
267
  enum rtx_code code;
268
 
269
  switch (GET_CODE (op))
270
    {
271
    default:
272
      break;
273
 
274
    case SUBREG:
275
      if (GET_MODE (op) != mode && mode != VOIDmode)
276
        return FALSE;
277
 
278
      subreg = SUBREG_REG (op);
279
      code = GET_CODE (subreg);
280
      if (code == MEM)
281
        return frv_legitimate_address_p (mode, XEXP (subreg, 0),
282
                                         reload_completed, FALSE, FALSE);
283
 
284
      return (code == REG);
285
 
286
    case REG:
287
      if (GET_MODE (op) != mode && mode != VOIDmode)
288
        return FALSE;
289
 
290
      return TRUE;
291
 
292
    case MEM:
293
      return frv_legitimate_memory_operand (op, mode, FALSE);
294
    }
295
 
296
  return FALSE;
297
})
298
 
299
;; Return true if we the operand is a valid destination for a movcc_fp
300
;; instruction.  This means rejecting fcc_operands, since we need
301
;; scratch registers to write to them.
302
 
303
(define_predicate "movcc_fp_destination_operand"
304
  (match_code "reg,subreg,mem")
305
{
306
  if (fcc_operand (op, mode))
307
    return FALSE;
308
 
309
  return move_destination_operand (op, mode);
310
})
311
 
312
;; Return true if operand is something that can be an input for a
313
;; conditional move operation.
314
 
315
(define_predicate "condexec_source_operand"
316
  (match_code "reg,subreg,const_int,mem,const_double")
317
{
318
  rtx subreg;
319
  enum rtx_code code;
320
 
321
  switch (GET_CODE (op))
322
    {
323
    default:
324
      break;
325
 
326
    case CONST_INT:
327
    case CONST_DOUBLE:
328
      return ZERO_P (op);
329
 
330
    case SUBREG:
331
      if (GET_MODE (op) != mode && mode != VOIDmode)
332
        return FALSE;
333
 
334
      subreg = SUBREG_REG (op);
335
      code = GET_CODE (subreg);
336
      if (code == MEM)
337
        return frv_legitimate_address_p (mode, XEXP (subreg, 0),
338
                                         reload_completed, TRUE, FALSE);
339
 
340
      return (code == REG);
341
 
342
    case REG:
343
      if (GET_MODE (op) != mode && mode != VOIDmode)
344
        return FALSE;
345
 
346
      return TRUE;
347
 
348
    case MEM:
349
      return frv_legitimate_memory_operand (op, mode, TRUE);
350
    }
351
 
352
  return FALSE;
353
})
354
 
355
;; Return true if operand is something that can be an output for a
356
;; conditional move operation.
357
 
358
(define_predicate "condexec_dest_operand"
359
  (match_code "reg,subreg,mem")
360
{
361
  rtx subreg;
362
  enum rtx_code code;
363
 
364
  switch (GET_CODE (op))
365
    {
366
    default:
367
      break;
368
 
369
    case SUBREG:
370
      if (GET_MODE (op) != mode && mode != VOIDmode)
371
        return FALSE;
372
 
373
      subreg = SUBREG_REG (op);
374
      code = GET_CODE (subreg);
375
      if (code == MEM)
376
        return frv_legitimate_address_p (mode, XEXP (subreg, 0),
377
                                         reload_completed, TRUE, FALSE);
378
 
379
      return (code == REG);
380
 
381
    case REG:
382
      if (GET_MODE (op) != mode && mode != VOIDmode)
383
        return FALSE;
384
 
385
      return TRUE;
386
 
387
    case MEM:
388
      return frv_legitimate_memory_operand (op, mode, TRUE);
389
    }
390
 
391
  return FALSE;
392
})
393
 
394
;; Return true if operand is a register of any flavor or a 0 of the
395
;; appropriate type.
396
 
397
(define_predicate "reg_or_0_operand"
398
  (match_code "reg,subreg,const_int,const_double")
399
{
400
  switch (GET_CODE (op))
401
    {
402
    default:
403
      break;
404
 
405
    case REG:
406
    case SUBREG:
407
      if (GET_MODE (op) != mode && mode != VOIDmode)
408
        return FALSE;
409
 
410
      return register_operand (op, mode);
411
 
412
    case CONST_INT:
413
    case CONST_DOUBLE:
414
      return ZERO_P (op);
415
    }
416
 
417
  return FALSE;
418
})
419
 
420
;; Return true if operand is the link register.
421
 
422
(define_predicate "lr_operand"
423
  (match_code "reg")
424
{
425
  if (GET_CODE (op) != REG)
426
    return FALSE;
427
 
428
  if (GET_MODE (op) != mode && mode != VOIDmode)
429
    return FALSE;
430
 
431
  if (REGNO (op) != LR_REGNO && REGNO (op) < FIRST_PSEUDO_REGISTER)
432
    return FALSE;
433
 
434
  return TRUE;
435
})
436
 
437
;; Return true if operand is a gpr register or a valid memory operand.
438
 
439
(define_predicate "gpr_or_memory_operand"
440
  (match_code "reg,subreg,mem")
441
{
442
  return (integer_register_operand (op, mode)
443
          || frv_legitimate_memory_operand (op, mode, FALSE));
444
})
445
 
446
;; Return true if operand is a gpr register, a valid memory operand,
447
;; or a memory operand that can be made valid using an additional gpr
448
;; register.
449
 
450
(define_predicate "gpr_or_memory_operand_with_scratch"
451
  (match_code "reg,subreg,mem")
452
{
453
  rtx addr;
454
 
455
  if (gpr_or_memory_operand (op, mode))
456
    return TRUE;
457
 
458
  if (GET_CODE (op) != MEM)
459
    return FALSE;
460
 
461
  if (GET_MODE (op) != mode)
462
    return FALSE;
463
 
464
  addr = XEXP (op, 0);
465
 
466
  if (GET_CODE (addr) != PLUS)
467
    return FALSE;
468
 
469
  if (!integer_register_operand (XEXP (addr, 0), Pmode))
470
    return FALSE;
471
 
472
  if (GET_CODE (XEXP (addr, 1)) != CONST_INT)
473
    return FALSE;
474
 
475
  return TRUE;
476
})
477
 
478
;; Return true if operand is a fpr register or a valid memory
479
;; operation.
480
 
481
(define_predicate "fpr_or_memory_operand"
482
  (match_code "reg,subreg,mem")
483
{
484
  return (fpr_operand (op, mode)
485
          || frv_legitimate_memory_operand (op, mode, FALSE));
486
})
487
 
488
;; Return 1 if operand is a 12 bit signed immediate.
489
 
490
(define_predicate "int12_operand"
491
  (match_code "const_int")
492
{
493
  if (GET_CODE (op) != CONST_INT)
494
    return FALSE;
495
 
496
  return IN_RANGE_P (INTVAL (op), -2048, 2047);
497
})
498
 
499
;; Return 1 if operand is an integer constant that takes 2
500
;; instructions to load up and can be split into sethi/setlo
501
;; instructions..
502
 
503
(define_predicate "int_2word_operand"
504
  (match_code "const_int,const_double,symbol_ref,label_ref,const")
505
{
506
  HOST_WIDE_INT value;
507
  REAL_VALUE_TYPE rv;
508
  long l;
509
 
510
  switch (GET_CODE (op))
511
    {
512
    default:
513
      break;
514
 
515
    case LABEL_REF:
516
      if (TARGET_FDPIC)
517
        return FALSE;
518
 
519
      return (flag_pic == 0);
520
 
521
    case CONST:
522
      if (flag_pic || TARGET_FDPIC)
523
        return FALSE;
524
 
525
      op = XEXP (op, 0);
526
      if (GET_CODE (op) == PLUS && GET_CODE (XEXP (op, 1)) == CONST_INT)
527
        op = XEXP (op, 0);
528
      return GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == LABEL_REF;
529
 
530
    case SYMBOL_REF:
531
      if (TARGET_FDPIC)
532
        return FALSE;
533
 
534
      /* small data references are already 1 word */
535
      return (flag_pic == 0) && (! SYMBOL_REF_SMALL_P (op));
536
 
537
    case CONST_INT:
538
      return ! IN_RANGE_P (INTVAL (op), -32768, 32767);
539
 
540
    case CONST_DOUBLE:
541
      if (GET_MODE (op) == SFmode)
542
        {
543
          REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
544
          REAL_VALUE_TO_TARGET_SINGLE (rv, l);
545
          value = l;
546
          return ! IN_RANGE_P (value, -32768, 32767);
547
        }
548
      else if (GET_MODE (op) == VOIDmode)
549
        {
550
          value = CONST_DOUBLE_LOW (op);
551
          return ! IN_RANGE_P (value, -32768, 32767);
552
        }
553
      break;
554
    }
555
 
556
  return FALSE;
557
})
558
 
559
;; Return true if operand is the uClinux PIC register.
560
 
561
(define_predicate "fdpic_operand"
562
  (match_code "reg")
563
{
564
  if (!TARGET_FDPIC)
565
    return FALSE;
566
 
567
  if (GET_CODE (op) != REG)
568
    return FALSE;
569
 
570
  if (GET_MODE (op) != mode && mode != VOIDmode)
571
    return FALSE;
572
 
573
  if (REGNO (op) != FDPIC_REGNO && REGNO (op) < FIRST_PSEUDO_REGISTER)
574
    return FALSE;
575
 
576
  return TRUE;
577
})
578
 
579
;; TODO: Add a comment here.
580
 
581
(define_predicate "fdpic_fptr_operand"
582
  (match_code "reg")
583
{
584
  if (GET_MODE (op) != mode && mode != VOIDmode)
585
    return FALSE;
586
  if (GET_CODE (op) != REG)
587
    return FALSE;
588
  if (REGNO (op) != FDPIC_FPTR_REGNO && REGNO (op) < FIRST_PSEUDO_REGISTER)
589
    return FALSE;
590
  return TRUE;
591
})
592
 
593
;; An address operand that may use a pair of registers, an addressing
594
;; mode that we reject in general.
595
 
596
(define_predicate "ldd_address_operand"
597
  (match_code "reg,subreg,plus")
598
{
599
  if (GET_MODE (op) != mode && GET_MODE (op) != VOIDmode)
600
    return FALSE;
601
 
602
  return frv_legitimate_address_p (DImode, op, reload_completed, FALSE, TRUE);
603
})
604
 
605
;; TODO: Add a comment here.
606
 
607
(define_predicate "got12_operand"
608
  (match_code "const")
609
{
610
  struct frv_unspec unspec;
611
 
612
  if (frv_const_unspec_p (op, &unspec))
613
    switch (unspec.reloc)
614
      {
615
      case R_FRV_GOT12:
616
      case R_FRV_GOTOFF12:
617
      case R_FRV_FUNCDESC_GOT12:
618
      case R_FRV_FUNCDESC_GOTOFF12:
619
      case R_FRV_GPREL12:
620
      case R_FRV_TLSMOFF12:
621
        return true;
622
      }
623
  return false;
624
})
625
 
626
;; Return true if OP is a valid const-unspec expression.
627
 
628
(define_predicate "const_unspec_operand"
629
  (match_code "const")
630
{
631
  struct frv_unspec unspec;
632
 
633
  return frv_const_unspec_p (op, &unspec);
634
})
635
 
636
;; Return true if operand is an icc register.
637
 
638
(define_predicate "icc_operand"
639
  (match_code "reg")
640
{
641
  int regno;
642
 
643
  if (GET_MODE (op) != mode && mode != VOIDmode)
644
    return FALSE;
645
 
646
  if (GET_CODE (op) != REG)
647
    return FALSE;
648
 
649
  regno = REGNO (op);
650
  return ICC_OR_PSEUDO_P (regno);
651
})
652
 
653
;; Return true if operand is an fcc register.
654
 
655
(define_predicate "fcc_operand"
656
  (match_code "reg")
657
{
658
  int regno;
659
 
660
  if (GET_MODE (op) != mode && mode != VOIDmode)
661
    return FALSE;
662
 
663
  if (GET_CODE (op) != REG)
664
    return FALSE;
665
 
666
  regno = REGNO (op);
667
  return FCC_OR_PSEUDO_P (regno);
668
})
669
 
670
;; Return true if operand is either an fcc or icc register.
671
 
672
(define_predicate "cc_operand"
673
  (match_code "reg")
674
{
675
  int regno;
676
 
677
  if (GET_MODE (op) != mode && mode != VOIDmode)
678
    return FALSE;
679
 
680
  if (GET_CODE (op) != REG)
681
    return FALSE;
682
 
683
  regno = REGNO (op);
684
  if (CC_OR_PSEUDO_P (regno))
685
    return TRUE;
686
 
687
  return FALSE;
688
})
689
 
690
;; Return true if operand is an integer CCR register.
691
 
692
(define_predicate "icr_operand"
693
  (match_code "reg")
694
{
695
  int regno;
696
 
697
  if (GET_MODE (op) != mode && mode != VOIDmode)
698
    return FALSE;
699
 
700
  if (GET_CODE (op) != REG)
701
    return FALSE;
702
 
703
  regno = REGNO (op);
704
  return ICR_OR_PSEUDO_P (regno);
705
})
706
 
707
;; Return true if operand is an fcc register.
708
 
709
(define_predicate "fcr_operand"
710
  (match_code "reg")
711
{
712
  int regno;
713
 
714
  if (GET_MODE (op) != mode && mode != VOIDmode)
715
    return FALSE;
716
 
717
  if (GET_CODE (op) != REG)
718
    return FALSE;
719
 
720
  regno = REGNO (op);
721
  return FCR_OR_PSEUDO_P (regno);
722
})
723
 
724
;; Return true if operand is either an fcc or icc register.
725
 
726
(define_predicate "cr_operand"
727
  (match_code "reg")
728
{
729
  int regno;
730
 
731
  if (GET_MODE (op) != mode && mode != VOIDmode)
732
    return FALSE;
733
 
734
  if (GET_CODE (op) != REG)
735
    return FALSE;
736
 
737
  regno = REGNO (op);
738
  if (CR_OR_PSEUDO_P (regno))
739
    return TRUE;
740
 
741
  return FALSE;
742
})
743
 
744
;; Return true if operand is a FPR register.
745
 
746
(define_predicate "fpr_operand"
747
  (match_code "reg,subreg")
748
{
749
  if (GET_MODE (op) != mode && mode != VOIDmode)
750
    return FALSE;
751
 
752
  if (GET_CODE (op) == SUBREG)
753
    {
754
      if (GET_CODE (SUBREG_REG (op)) != REG)
755
        return register_operand (op, mode);
756
 
757
      op = SUBREG_REG (op);
758
    }
759
 
760
  if (GET_CODE (op) != REG)
761
    return FALSE;
762
 
763
  return FPR_OR_PSEUDO_P (REGNO (op));
764
})
765
 
766
;; Return true if operand is an even GPR or FPR register.
767
 
768
(define_predicate "even_reg_operand"
769
  (match_code "reg,subreg")
770
{
771
  int regno;
772
 
773
  if (GET_MODE (op) != mode && mode != VOIDmode)
774
    return FALSE;
775
 
776
  if (GET_CODE (op) == SUBREG)
777
    {
778
      if (GET_CODE (SUBREG_REG (op)) != REG)
779
        return register_operand (op, mode);
780
 
781
      op = SUBREG_REG (op);
782
    }
783
 
784
  if (GET_CODE (op) != REG)
785
    return FALSE;
786
 
787
  regno = REGNO (op);
788
  if (regno >= FIRST_PSEUDO_REGISTER)
789
    return TRUE;
790
 
791
  if (GPR_P (regno))
792
    return (((regno - GPR_FIRST) & 1) == 0);
793
 
794
  if (FPR_P (regno))
795
    return (((regno - FPR_FIRST) & 1) == 0);
796
 
797
  return FALSE;
798
})
799
 
800
;; Return true if operand is an odd GPR register.
801
 
802
(define_predicate "odd_reg_operand"
803
  (match_code "reg,subreg")
804
{
805
  int regno;
806
 
807
  if (GET_MODE (op) != mode && mode != VOIDmode)
808
    return FALSE;
809
 
810
  if (GET_CODE (op) == SUBREG)
811
    {
812
      if (GET_CODE (SUBREG_REG (op)) != REG)
813
        return register_operand (op, mode);
814
 
815
      op = SUBREG_REG (op);
816
    }
817
 
818
  if (GET_CODE (op) != REG)
819
    return FALSE;
820
 
821
  regno = REGNO (op);
822
  /* Assume that reload will give us an even register.  */
823
  if (regno >= FIRST_PSEUDO_REGISTER)
824
    return FALSE;
825
 
826
  if (GPR_P (regno))
827
    return (((regno - GPR_FIRST) & 1) != 0);
828
 
829
  if (FPR_P (regno))
830
    return (((regno - FPR_FIRST) & 1) != 0);
831
 
832
  return FALSE;
833
})
834
 
835
;; Return true if operand is an even GPR register.
836
 
837
(define_predicate "even_gpr_operand"
838
  (match_code "reg,subreg")
839
{
840
  int regno;
841
 
842
  if (GET_MODE (op) != mode && mode != VOIDmode)
843
    return FALSE;
844
 
845
  if (GET_CODE (op) == SUBREG)
846
    {
847
      if (GET_CODE (SUBREG_REG (op)) != REG)
848
        return register_operand (op, mode);
849
 
850
      op = SUBREG_REG (op);
851
    }
852
 
853
  if (GET_CODE (op) != REG)
854
    return FALSE;
855
 
856
  regno = REGNO (op);
857
  if (regno >= FIRST_PSEUDO_REGISTER)
858
    return TRUE;
859
 
860
  if (! GPR_P (regno))
861
    return FALSE;
862
 
863
  return (((regno - GPR_FIRST) & 1) == 0);
864
})
865
 
866
;; Return true if operand is an odd GPR register.
867
 
868
(define_predicate "odd_gpr_operand"
869
  (match_code "reg,subreg")
870
{
871
  int regno;
872
 
873
  if (GET_MODE (op) != mode && mode != VOIDmode)
874
    return FALSE;
875
 
876
  if (GET_CODE (op) == SUBREG)
877
    {
878
      if (GET_CODE (SUBREG_REG (op)) != REG)
879
        return register_operand (op, mode);
880
 
881
      op = SUBREG_REG (op);
882
    }
883
 
884
  if (GET_CODE (op) != REG)
885
    return FALSE;
886
 
887
  regno = REGNO (op);
888
  /* Assume that reload will give us an even register.  */
889
  if (regno >= FIRST_PSEUDO_REGISTER)
890
    return FALSE;
891
 
892
  if (! GPR_P (regno))
893
    return FALSE;
894
 
895
  return (((regno - GPR_FIRST) & 1) != 0);
896
})
897
 
898
;; Return true if operand is a quad aligned FPR register.
899
 
900
(define_predicate "quad_fpr_operand"
901
  (match_code "reg,subreg")
902
{
903
  int regno;
904
 
905
  if (GET_MODE (op) != mode && mode != VOIDmode)
906
    return FALSE;
907
 
908
  if (GET_CODE (op) == SUBREG)
909
    {
910
      if (GET_CODE (SUBREG_REG (op)) != REG)
911
        return register_operand (op, mode);
912
 
913
      op = SUBREG_REG (op);
914
    }
915
 
916
  if (GET_CODE (op) != REG)
917
    return FALSE;
918
 
919
  regno = REGNO (op);
920
  if (regno >= FIRST_PSEUDO_REGISTER)
921
    return TRUE;
922
 
923
  if (! FPR_P (regno))
924
    return FALSE;
925
 
926
  return (((regno - FPR_FIRST) & 3) == 0);
927
})
928
 
929
;; Return true if operand is an even FPR register.
930
 
931
(define_predicate "even_fpr_operand"
932
  (match_code "reg,subreg")
933
{
934
  int regno;
935
 
936
  if (GET_MODE (op) != mode && mode != VOIDmode)
937
    return FALSE;
938
 
939
  if (GET_CODE (op) == SUBREG)
940
    {
941
      if (GET_CODE (SUBREG_REG (op)) != REG)
942
        return register_operand (op, mode);
943
 
944
      op = SUBREG_REG (op);
945
    }
946
 
947
  if (GET_CODE (op) != REG)
948
    return FALSE;
949
 
950
  regno = REGNO (op);
951
  if (regno >= FIRST_PSEUDO_REGISTER)
952
    return TRUE;
953
 
954
  if (! FPR_P (regno))
955
    return FALSE;
956
 
957
  return (((regno - FPR_FIRST) & 1) == 0);
958
})
959
 
960
;; Return true if operand is an odd FPR register.
961
 
962
(define_predicate "odd_fpr_operand"
963
  (match_code "reg,subreg")
964
{
965
  int regno;
966
 
967
  if (GET_MODE (op) != mode && mode != VOIDmode)
968
    return FALSE;
969
 
970
  if (GET_CODE (op) == SUBREG)
971
    {
972
      if (GET_CODE (SUBREG_REG (op)) != REG)
973
        return register_operand (op, mode);
974
 
975
      op = SUBREG_REG (op);
976
    }
977
 
978
  if (GET_CODE (op) != REG)
979
    return FALSE;
980
 
981
  regno = REGNO (op);
982
  /* Assume that reload will give us an even register.  */
983
  if (regno >= FIRST_PSEUDO_REGISTER)
984
    return FALSE;
985
 
986
  if (! FPR_P (regno))
987
    return FALSE;
988
 
989
  return (((regno - FPR_FIRST) & 1) != 0);
990
})
991
 
992
;; Return true if operand is a 2 word memory address that can be
993
;; loaded in one instruction to load or store.  We assume the stack
994
;; and frame pointers are suitably aligned, and variables in the small
995
;; data area.  FIXME -- at some we should recognize other globals and
996
;; statics. We can't assume that any old pointer is aligned, given
997
;; that arguments could be passed on an odd word on the stack and the
998
;; address taken and passed through to another function.
999
 
1000
(define_predicate "dbl_memory_one_insn_operand"
1001
  (match_code "mem")
1002
{
1003
  rtx addr;
1004
  rtx addr_reg;
1005
 
1006
  if (! TARGET_DWORD)
1007
    return FALSE;
1008
 
1009
  if (GET_CODE (op) != MEM)
1010
    return FALSE;
1011
 
1012
  if (mode != VOIDmode && GET_MODE_SIZE (mode) != 2*UNITS_PER_WORD)
1013
    return FALSE;
1014
 
1015
  addr = XEXP (op, 0);
1016
  if (GET_CODE (addr) == REG)
1017
    addr_reg = addr;
1018
 
1019
  else if (GET_CODE (addr) == PLUS)
1020
    {
1021
      rtx addr0 = XEXP (addr, 0);
1022
      rtx addr1 = XEXP (addr, 1);
1023
 
1024
      if (GET_CODE (addr0) != REG)
1025
        return FALSE;
1026
 
1027
      if (got12_operand (addr1, VOIDmode))
1028
        return TRUE;
1029
 
1030
      if (GET_CODE (addr1) != CONST_INT)
1031
        return FALSE;
1032
 
1033
      if ((INTVAL (addr1) & 7) != 0)
1034
        return FALSE;
1035
 
1036
      addr_reg = addr0;
1037
    }
1038
 
1039
  else
1040
    return FALSE;
1041
 
1042
  if (addr_reg == frame_pointer_rtx || addr_reg == stack_pointer_rtx)
1043
    return TRUE;
1044
 
1045
  return FALSE;
1046
})
1047
 
1048
;; Return true if operand is a 2 word memory address that needs to use
1049
;; two instructions to load or store.
1050
 
1051
(define_predicate "dbl_memory_two_insn_operand"
1052
  (match_code "mem")
1053
{
1054
  if (GET_CODE (op) != MEM)
1055
    return FALSE;
1056
 
1057
  if (mode != VOIDmode && GET_MODE_SIZE (mode) != 2*UNITS_PER_WORD)
1058
    return FALSE;
1059
 
1060
  if (! TARGET_DWORD)
1061
    return TRUE;
1062
 
1063
  return ! dbl_memory_one_insn_operand (op, mode);
1064
})
1065
 
1066
;; Return true if operand is a memory reference suitable for a call.
1067
 
1068
(define_predicate "call_operand"
1069
  (match_code "reg,subreg,const_int,const,symbol_ref")
1070
{
1071
  if (GET_MODE (op) != mode && mode != VOIDmode && GET_CODE (op) != CONST_INT)
1072
    return FALSE;
1073
 
1074
  if (GET_CODE (op) == SYMBOL_REF)
1075
    return !TARGET_LONG_CALLS || SYMBOL_REF_LOCAL_P (op);
1076
 
1077
  /* Note this doesn't allow reg+reg or reg+imm12 addressing (which should
1078
     never occur anyway), but prevents reload from not handling the case
1079
     properly of a call through a pointer on a function that calls
1080
     vfork/setjmp, etc. due to the need to flush all of the registers to stack.  */
1081
  return gpr_or_int12_operand (op, mode);
1082
})
1083
 
1084
;; Return true if operand is a memory reference suitable for a
1085
;; sibcall.
1086
 
1087
(define_predicate "sibcall_operand"
1088
  (match_code "reg,subreg,const_int,const")
1089
{
1090
  if (GET_MODE (op) != mode && mode != VOIDmode && GET_CODE (op) != CONST_INT)
1091
    return FALSE;
1092
 
1093
  /* Note this doesn't allow reg+reg or reg+imm12 addressing (which should
1094
     never occur anyway), but prevents reload from not handling the case
1095
     properly of a call through a pointer on a function that calls
1096
     vfork/setjmp, etc. due to the need to flush all of the registers to stack.  */
1097
  return gpr_or_int12_operand (op, mode);
1098
})
1099
 
1100
;; Return 1 if operand is an integer constant with the bottom 16 bits
1101
;; clear.
1102
 
1103
(define_predicate "upper_int16_operand"
1104
  (match_code "const_int")
1105
{
1106
  if (GET_CODE (op) != CONST_INT)
1107
    return FALSE;
1108
 
1109
  return ((INTVAL (op) & 0xffff) == 0);
1110
})
1111
 
1112
;; Return 1 if operand is a 16 bit unsigned immediate.
1113
 
1114
(define_predicate "uint16_operand"
1115
  (match_code "const_int")
1116
{
1117
  if (GET_CODE (op) != CONST_INT)
1118
    return FALSE;
1119
 
1120
  return IN_RANGE_P (INTVAL (op), 0, 0xffff);
1121
})
1122
 
1123
;; Returns 1 if OP is either a SYMBOL_REF or a constant.
1124
 
1125
(define_predicate "symbolic_operand"
1126
  (match_code "symbol_ref,const_int")
1127
{
1128
  enum rtx_code c = GET_CODE (op);
1129
 
1130
  if (c == CONST)
1131
    {
1132
      /* Allow (const:SI (plus:SI (symbol_ref) (const_int))).  */
1133
      return GET_MODE (op) == SImode
1134
        && GET_CODE (XEXP (op, 0)) == PLUS
1135
        && GET_CODE (XEXP (XEXP (op, 0), 0)) == SYMBOL_REF
1136
        && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST_INT;
1137
    }
1138
 
1139
  return c == SYMBOL_REF || c == CONST_INT;
1140
})
1141
 
1142
;; Return true if operator is a kind of relational operator.
1143
 
1144
(define_predicate "relational_operator"
1145
  (match_code "eq,ne,le,lt,ge,gt,leu,ltu,geu,gtu")
1146
{
1147
  return (integer_relational_operator (op, mode)
1148
          || float_relational_operator (op, mode));
1149
})
1150
 
1151
;; Return true if OP is a relational operator suitable for CCmode,
1152
;; CC_UNSmode or CC_NZmode.
1153
 
1154
(define_predicate "integer_relational_operator"
1155
  (match_code "eq,ne,le,lt,ge,gt,leu,ltu,geu,gtu")
1156
{
1157
  if (mode != VOIDmode && mode != GET_MODE (op))
1158
    return FALSE;
1159
 
1160
  /* The allowable relations depend on the mode of the ICC register.  */
1161
  switch (GET_CODE (op))
1162
    {
1163
    default:
1164
      return FALSE;
1165
 
1166
    case EQ:
1167
    case NE:
1168
    case LT:
1169
    case GE:
1170
      return (GET_MODE (XEXP (op, 0)) == CC_NZmode
1171
              || GET_MODE (XEXP (op, 0)) == CCmode);
1172
 
1173
    case LE:
1174
    case GT:
1175
      return GET_MODE (XEXP (op, 0)) == CCmode;
1176
 
1177
    case GTU:
1178
    case GEU:
1179
    case LTU:
1180
    case LEU:
1181
      return (GET_MODE (XEXP (op, 0)) == CC_NZmode
1182
              || GET_MODE (XEXP (op, 0)) == CC_UNSmode);
1183
    }
1184
})
1185
 
1186
;; Return true if operator is a floating point relational operator.
1187
 
1188
(define_predicate "float_relational_operator"
1189
  (match_code "eq,ne,le,lt,ge,gt")
1190
{
1191
  if (mode != VOIDmode && mode != GET_MODE (op))
1192
    return FALSE;
1193
 
1194
  switch (GET_CODE (op))
1195
    {
1196
    default:
1197
      return FALSE;
1198
 
1199
    case EQ: case NE:
1200
    case LE: case LT:
1201
    case GE: case GT:
1202
#if 0
1203
    case UEQ: case UNE:
1204
    case ULE: case ULT:
1205
    case UGE: case UGT:
1206
    case ORDERED:
1207
    case UNORDERED:
1208
#endif
1209
      return GET_MODE (XEXP (op, 0)) == CC_FPmode;
1210
    }
1211
})
1212
 
1213
;; Return true if operator is EQ/NE of a conditional execution
1214
;; register.
1215
 
1216
(define_predicate "ccr_eqne_operator"
1217
  (match_code "eq,ne")
1218
{
1219
  enum machine_mode op_mode = GET_MODE (op);
1220
  rtx op0;
1221
  rtx op1;
1222
  int regno;
1223
 
1224
  if (mode != VOIDmode && op_mode != mode)
1225
    return FALSE;
1226
 
1227
  switch (GET_CODE (op))
1228
    {
1229
    default:
1230
      return FALSE;
1231
 
1232
    case EQ:
1233
    case NE:
1234
      break;
1235
    }
1236
 
1237
  op1 = XEXP (op, 1);
1238
  if (op1 != const0_rtx)
1239
    return FALSE;
1240
 
1241
  op0 = XEXP (op, 0);
1242
  if (GET_CODE (op0) != REG)
1243
    return FALSE;
1244
 
1245
  regno = REGNO (op0);
1246
  if (op_mode == CC_CCRmode && CR_OR_PSEUDO_P (regno))
1247
    return TRUE;
1248
 
1249
  return FALSE;
1250
})
1251
 
1252
;; Return true if operator is a minimum or maximum operator (both
1253
;; signed and unsigned).
1254
 
1255
(define_predicate "minmax_operator"
1256
  (match_code "smin,smax,umin,umax")
1257
{
1258
  if (mode != VOIDmode && mode != GET_MODE (op))
1259
    return FALSE;
1260
 
1261
  switch (GET_CODE (op))
1262
    {
1263
    default:
1264
      return FALSE;
1265
 
1266
    case SMIN:
1267
    case SMAX:
1268
    case UMIN:
1269
    case UMAX:
1270
      break;
1271
    }
1272
 
1273
  if (! integer_register_operand (XEXP (op, 0), mode))
1274
    return FALSE;
1275
 
1276
  if (! gpr_or_int10_operand (XEXP (op, 1), mode))
1277
    return FALSE;
1278
 
1279
  return TRUE;
1280
})
1281
 
1282
;; Return true if operator is an integer binary operator that can
1283
;; executed conditionally and takes 1 cycle.
1284
 
1285
(define_predicate "condexec_si_binary_operator"
1286
  (match_code "plus,minus,and,ior,xor,ashift,ashiftrt,lshiftrt")
1287
{
1288
  enum machine_mode op_mode = GET_MODE (op);
1289
 
1290
  if (mode != VOIDmode && op_mode != mode)
1291
    return FALSE;
1292
 
1293
  switch (GET_CODE (op))
1294
    {
1295
    default:
1296
      return FALSE;
1297
 
1298
    case PLUS:
1299
    case MINUS:
1300
    case AND:
1301
    case IOR:
1302
    case XOR:
1303
    case ASHIFT:
1304
    case ASHIFTRT:
1305
    case LSHIFTRT:
1306
      return TRUE;
1307
    }
1308
})
1309
 
1310
;; Return true if operator is an integer binary operator that can be
1311
;; executed conditionally by a media instruction.
1312
 
1313
(define_predicate "condexec_si_media_operator"
1314
  (match_code "and,ior,xor")
1315
{
1316
  enum machine_mode op_mode = GET_MODE (op);
1317
 
1318
  if (mode != VOIDmode && op_mode != mode)
1319
    return FALSE;
1320
 
1321
  switch (GET_CODE (op))
1322
    {
1323
    default:
1324
      return FALSE;
1325
 
1326
    case AND:
1327
    case IOR:
1328
    case XOR:
1329
      return TRUE;
1330
    }
1331
})
1332
 
1333
;; Return true if operator is an integer division operator that can
1334
;; executed conditionally.
1335
 
1336
(define_predicate "condexec_si_divide_operator"
1337
  (match_code "div,udiv")
1338
{
1339
  enum machine_mode op_mode = GET_MODE (op);
1340
 
1341
  if (mode != VOIDmode && op_mode != mode)
1342
    return FALSE;
1343
 
1344
  switch (GET_CODE (op))
1345
    {
1346
    default:
1347
      return FALSE;
1348
 
1349
    case DIV:
1350
    case UDIV:
1351
      return TRUE;
1352
    }
1353
})
1354
 
1355
;; Return true if operator is an integer unary operator that can
1356
;; executed conditionally.
1357
 
1358
(define_predicate "condexec_si_unary_operator"
1359
  (match_code "not,neg")
1360
{
1361
  enum machine_mode op_mode = GET_MODE (op);
1362
 
1363
  if (mode != VOIDmode && op_mode != mode)
1364
    return FALSE;
1365
 
1366
  switch (GET_CODE (op))
1367
    {
1368
    default:
1369
      return FALSE;
1370
 
1371
    case NEG:
1372
    case NOT:
1373
      return TRUE;
1374
    }
1375
})
1376
 
1377
;; Return true if operator is an addition or subtraction
1378
;; expression. Such expressions can be evaluated conditionally by
1379
;; floating-point instructions.
1380
 
1381
(define_predicate "condexec_sf_add_operator"
1382
  (match_code "plus,minus")
1383
{
1384
  enum machine_mode op_mode = GET_MODE (op);
1385
 
1386
  if (mode != VOIDmode && op_mode != mode)
1387
    return FALSE;
1388
 
1389
  switch (GET_CODE (op))
1390
    {
1391
    default:
1392
      return FALSE;
1393
 
1394
    case PLUS:
1395
    case MINUS:
1396
      return TRUE;
1397
    }
1398
})
1399
 
1400
;; Return true if operator is a conversion-type expression that can be
1401
;; evaluated conditionally by floating-point instructions.
1402
 
1403
(define_predicate "condexec_sf_conv_operator"
1404
  (match_code "abs,neg")
1405
{
1406
  enum machine_mode op_mode = GET_MODE (op);
1407
 
1408
  if (mode != VOIDmode && op_mode != mode)
1409
    return FALSE;
1410
 
1411
  switch (GET_CODE (op))
1412
    {
1413
    default:
1414
      return FALSE;
1415
 
1416
    case NEG:
1417
    case ABS:
1418
      return TRUE;
1419
    }
1420
})
1421
 
1422
;; Return true if OP is an integer binary operator that can be
1423
;; combined with a (set ... (compare:CC_NZ ...)) pattern.
1424
 
1425
(define_predicate "intop_compare_operator"
1426
  (match_code "plus,minus,and,ior,xor,ashift,ashiftrt,lshiftrt")
1427
{
1428
  if (mode != VOIDmode && GET_MODE (op) != mode)
1429
    return FALSE;
1430
 
1431
  switch (GET_CODE (op))
1432
    {
1433
    default:
1434
      return FALSE;
1435
 
1436
    case PLUS:
1437
    case MINUS:
1438
    case AND:
1439
    case IOR:
1440
    case XOR:
1441
    case ASHIFTRT:
1442
    case LSHIFTRT:
1443
      return GET_MODE (op) == SImode;
1444
    }
1445
})
1446
 
1447
;; Return 1 if operand is a register or 6 bit signed immediate.
1448
 
1449
(define_predicate "fpr_or_int6_operand"
1450
  (match_code "reg,subreg,const_int")
1451
{
1452
  if (GET_CODE (op) == CONST_INT)
1453
    return IN_RANGE_P (INTVAL (op), -32, 31);
1454
 
1455
  if (GET_MODE (op) != mode && mode != VOIDmode)
1456
    return FALSE;
1457
 
1458
  if (GET_CODE (op) == SUBREG)
1459
    {
1460
      if (GET_CODE (SUBREG_REG (op)) != REG)
1461
        return register_operand (op, mode);
1462
 
1463
      op = SUBREG_REG (op);
1464
    }
1465
 
1466
  if (GET_CODE (op) != REG)
1467
    return FALSE;
1468
 
1469
  return FPR_OR_PSEUDO_P (REGNO (op));
1470
})
1471
 
1472
;; Return 1 if operand is a 6 bit signed immediate.
1473
 
1474
(define_predicate "int6_operand"
1475
  (match_code "const_int")
1476
{
1477
  if (GET_CODE (op) != CONST_INT)
1478
    return FALSE;
1479
 
1480
  return IN_RANGE_P (INTVAL (op), -32, 31);
1481
})
1482
 
1483
;; Return 1 if operand is a 5 bit signed immediate.
1484
 
1485
(define_predicate "int5_operand"
1486
  (match_code "const_int")
1487
{
1488
  return GET_CODE (op) == CONST_INT && IN_RANGE_P (INTVAL (op), -16, 15);
1489
})
1490
 
1491
;; Return 1 if operand is a 5 bit unsigned immediate.
1492
 
1493
(define_predicate "uint5_operand"
1494
  (match_code "const_int")
1495
{
1496
  return GET_CODE (op) == CONST_INT && IN_RANGE_P (INTVAL (op), 0, 31);
1497
})
1498
 
1499
;; Return 1 if operand is a 4 bit unsigned immediate.
1500
 
1501
(define_predicate "uint4_operand"
1502
  (match_code "const_int")
1503
{
1504
  return GET_CODE (op) == CONST_INT && IN_RANGE_P (INTVAL (op), 0, 15);
1505
})
1506
 
1507
;; Return 1 if operand is a 1 bit unsigned immediate (0 or 1).
1508
 
1509
(define_predicate "uint1_operand"
1510
  (match_code "const_int")
1511
{
1512
  return GET_CODE (op) == CONST_INT && IN_RANGE_P (INTVAL (op), 0, 1);
1513
})
1514
 
1515
;; Return 1 if operand is a valid ACC register number.
1516
 
1517
(define_predicate "acc_operand"
1518
  (match_code "reg,subreg")
1519
{
1520
  return ((mode == VOIDmode || mode == GET_MODE (op))
1521
          && REG_P (op) && ACC_P (REGNO (op))
1522
          && ((REGNO (op) - ACC_FIRST) & ~ACC_MASK) == 0);
1523
})
1524
 
1525
;; Return 1 if operand is a valid even ACC register number.
1526
 
1527
(define_predicate "even_acc_operand"
1528
  (match_code "reg,subreg")
1529
{
1530
  return acc_operand (op, mode) && ((REGNO (op) - ACC_FIRST) & 1) == 0;
1531
})
1532
 
1533
;; Return 1 if operand is zero or four.
1534
 
1535
(define_predicate "quad_acc_operand"
1536
  (match_code "reg,subreg")
1537
{
1538
  return acc_operand (op, mode) && ((REGNO (op) - ACC_FIRST) & 3) == 0;
1539
})
1540
 
1541
;; Return 1 if operand is a valid ACCG register number.
1542
 
1543
(define_predicate "accg_operand"
1544
  (match_code "reg,subreg")
1545
{
1546
  return ((mode == VOIDmode || mode == GET_MODE (op))
1547
          && REG_P (op) && ACCG_P (REGNO (op))
1548
          && ((REGNO (op) - ACCG_FIRST) & ~ACC_MASK) == 0);
1549
})

powered by: WebSVN 2.1.0

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