aboutsummaryrefslogtreecommitdiffstats
path: root/src/synth/synth-ieee-numeric_std.ads
blob: 4c58884631100d8b3a077b4ea6f0b38135a25362 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
--  numeric_std
--  Copyright (C) 2019 Tristan Gingold
--
--  This file is part of GHDL.
--
--  This program is free software: you can redistribute it and/or modify
--  it under the terms of the GNU General Public License as published by
--  the Free Software Foundation, either version 2 of the License, or
--  (at your option) any later version.
--
--  This program is distributed in the hope that it will be useful,
--  but WITHOUT ANY WARRANTY; without even the implied warranty of
--  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--  GNU General Public License for more details.
--
--  You should have received a copy of the GNU General Public License
--  along with this program.  If not, see <gnu.org/licenses>.

with Types; use Types;

with Elab.Vhdl_Objtypes; use Elab.Vhdl_Objtypes;

package Synth.Ieee.Numeric_Std is
   --  Reminder: vectors elements are from left to right.

   function Compare_Uns_Uns (Left, Right : Memtyp;
                             Err : Order_Type;
                             Loc : Location_Type) return Order_Type;
   function Compare_Uns_Nat (Left, Right : Memtyp;
                             Err : Order_Type;
                             Loc : Location_Type) return Order_Type;
   function Compare_Nat_Uns (Left, Right : Memtyp;
                             Err : Order_Type;
                             Loc : Location_Type) return Order_Type;
   function Compare_Sgn_Sgn (Left, Right : Memtyp;
                             Err : Order_Type;
                             Loc : Location_Type) return Order_Type;
   function Compare_Sgn_Int (Left, Right : Memtyp;
                             Err : Order_Type;
                             Loc : Location_Type) return Order_Type;

   --  Unary "-"
   function Neg_Vec (V : Memtyp; Loc : Location_Type) return Memtyp;

   --  "abs"
   function Abs_Vec (V : Memtyp; Loc : Location_Type) return Memtyp;

   --  "+"
   function Add_Uns_Uns (L, R : Memtyp; Loc : Location_Type) return Memtyp;
   function Add_Sgn_Sgn (L, R : Memtyp; Loc : Location_Type) return Memtyp;
   function Add_Sgn_Int (L : Memtyp; R : Int64; Loc : Location_Type)
                        return Memtyp;
   function Add_Uns_Nat (L : Memtyp; R : Uns64; Loc : Location_Type)
                        return Memtyp;

   --  "-"
   function Sub_Uns_Uns (L, R : Memtyp; Loc : Location_Type) return Memtyp;
   function Sub_Uns_Nat (L : Memtyp; R : Uns64; Loc : Location_Type)
                        return Memtyp;
   function Sub_Nat_Uns (L : Uns64; R : Memtyp; Loc : Location_Type)
                        return Memtyp;

   function Sub_Sgn_Sgn (L, R : Memtyp; Loc : Location_Type) return Memtyp;
   function Sub_Sgn_Int (L : Memtyp; R : Int64; Loc : Location_Type)
                        return Memtyp;
   function Sub_Int_Sgn (L : Int64; R : Memtyp; Loc : Location_Type)
                        return Memtyp;

   --  "*"
   function Mul_Uns_Uns (L, R : Memtyp; Loc : Location_Type) return Memtyp;
   function Mul_Nat_Uns (L : Uns64; R : Memtyp; Loc : Location_Type)
                        return Memtyp;
   function Mul_Uns_Nat (L : Memtyp; R : Uns64; Loc : Location_Type)
                        return Memtyp;

   function Mul_Sgn_Sgn (L, R : Memtyp; Loc : Location_Type) return Memtyp;
   function Mul_Int_Sgn (L : Int64; R : Memtyp; Loc : Location_Type)
                        return Memtyp;
   function Mul_Sgn_Int (L : Memtyp; R : Int64; Loc : Location_Type)
                        return Memtyp;

   --  "/"
   function Div_Uns_Uns (L, R : Memtyp; Loc : Location_Type) return Memtyp;
   function Div_Uns_Nat (L : Memtyp; R : Uns64; Loc : Location_Type)
                        return Memtyp;
   function Div_Nat_Uns (L : Uns64; R : Memtyp; Loc : Location_Type)
                        return Memtyp;
   function Div_Sgn_Sgn (L, R : Memtyp; Loc : Location_Type) return Memtyp;
   function Div_Sgn_Int (L : Memtyp; R : Int64; Loc : Location_Type)
                        return Memtyp;
   function Div_Int_Sgn (L : Int64; R : Memtyp; Loc : Location_Type)
                        return Memtyp;

   --  "rem"
   function Rem_Uns_Uns (L, R : Memtyp; Loc : Location_Type) return Memtyp;
   function Rem_Uns_Nat (L : Memtyp; R : Uns64; Loc : Location_Type)
                        return Memtyp;
   function Rem_Nat_Uns (L : Uns64; R : Memtyp; Loc : Location_Type)
                        return Memtyp;
   function Rem_Sgn_Sgn (L, R : Memtyp; Loc : Location_Type) return Memtyp;
   function Rem_Sgn_Int (L : Memtyp; R : Int64; Loc : Location_Type)
                        return Memtyp;
   function Rem_Int_Sgn (L : Int64; R : Memtyp; Loc : Location_Type)
                        return Memtyp;

   --  "mod"
   function Mod_Sgn_Sgn (L, R : Memtyp; Loc : Location_Type)
                        return Memtyp;
   function Mod_Sgn_Int (L : Memtyp; R : Int64; Loc : Location_Type)
                        return Memtyp;
   function Mod_Int_Sgn (L : Int64; R : Memtyp; Loc : Location_Type)
                        return Memtyp;

   --  Shift
   function Shift_Vec (Val : Memtyp;
                       Amt : Uns32;
                       Right : Boolean;
                       Arith : Boolean) return Memtyp;

   --  Rotate
   function Rotate_Vec (Val : Memtyp;
                        Amt : Uns32;
                        Right : Boolean) return Memtyp;

   function Resize_Vec (Val : Memtyp;
                        Size : Uns32;
                        Signed : Boolean) return Memtyp;

   --  Minimum/Maximum.
   function Minmax (L, R : Memtyp; Is_Signed : Boolean; Is_Max : Boolean)
                   return Memtyp;

   --  Find_Rightmost/Find_Leftmost
   function Find_Rightmost (Arg : Memtyp; Val : Memtyp) return Int32;
   function Find_Leftmost (Arg : Memtyp; Val : Memtyp) return Int32;
end Synth.Ieee.Numeric_Std;