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

Subversion Repositories common_pkg

[/] [common_pkg/] [trunk/] [common_pkg.vhd] - Blame information for rev 16

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 6 danv 
-------------------------------------------------------------------------------
2 
--
3 16 danv 
-- Copyright 2020
4 6 danv 
-- ASTRON (Netherlands Institute for Radio Astronomy) <http://www.astron.nl/>
5 
-- P.O.Box 2, 7990 AA Dwingeloo, The Netherlands
6 16 danv 
--
7 
-- Licensed under the Apache License, Version 2.0 (the "License");
8 
-- you may not use this file except in compliance with the License.
9 
-- You may obtain a copy of the License at
10 
--
11 
--     http://www.apache.org/licenses/LICENSE-2.0
12 
--
13 
-- Unless required by applicable law or agreed to in writing, software
14 
-- distributed under the License is distributed on an "AS IS" BASIS,
15 
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 
-- See the License for the specific language governing permissions and
17 
-- limitations under the License.
18 6 danv 
--
19 
-------------------------------------------------------------------------------
20 
 
21 9 danv 
-- Author:
22 
-- . Eric Kooistra
23 
-- Purpose:
24 
-- . Collection of commonly used base funtions
25 
-- Interface:
26 
-- . [n/a]
27 
-- Description:
28 
-- . This is a package containing generic constants and functions.
29 
-- . More information can be found in the comments near the code.
30 
 
31 6 danv 
LIBRARY IEEE;
32 
USE IEEE.STD_LOGIC_1164.ALL;
33 
USE IEEE.NUMERIC_STD.ALL;
34 
USE IEEE.MATH_REAL.ALL;
35 
 
36 
PACKAGE common_pkg IS
37 
 
38 
  -- CONSTANT DECLARATIONS ----------------------------------------------------
39 
 
40 
  -- some integers
41 
  CONSTANT c_0                    : NATURAL := 0;
42 
  CONSTANT c_zero                 : NATURAL := 0;
43 
  CONSTANT c_1                    : NATURAL := 1;
44 
  CONSTANT c_one                  : NATURAL := 1;
45 
  CONSTANT c_2                    : NATURAL := 2;
46 
  CONSTANT c_4                    : NATURAL := 4;
47 
  CONSTANT c_quad                 : NATURAL := 4;
48 
  CONSTANT c_8                    : NATURAL := 8;
49 
  CONSTANT c_16                   : NATURAL := 16;
50 
  CONSTANT c_32                   : NATURAL := 32;
51 
  CONSTANT c_64                   : NATURAL := 64;
52 
  CONSTANT c_128                  : NATURAL := 128;
53 
  CONSTANT c_256                  : NATURAL := 256;
54 
 
55 
  -- widths and sizes
56 
  CONSTANT c_halfword_sz          : NATURAL := 2;
57 
  CONSTANT c_word_sz              : NATURAL := 4;
58 
  CONSTANT c_longword_sz          : NATURAL := 8;
59 
  CONSTANT c_nibble_w             : NATURAL := 4;
60 
  CONSTANT c_byte_w               : NATURAL := 8;
61 
  CONSTANT c_octet_w              : NATURAL := 8;
62 
  CONSTANT c_halfword_w           : NATURAL := c_byte_w*c_halfword_sz;
63 
  CONSTANT c_word_w               : NATURAL := c_byte_w*c_word_sz;
64 
  CONSTANT c_integer_w            : NATURAL := 32;              -- unfortunately VHDL integer type is limited to 32 bit values
65 
  CONSTANT c_natural_w            : NATURAL := c_integer_w-1;   -- unfortunately VHDL natural type is limited to 31 bit values (0 and the positive subset of the VHDL integer type0
66 
  CONSTANT c_longword_w           : NATURAL := c_byte_w*c_longword_sz;
67 
 
68 
  -- logic
69 
  CONSTANT c_sl0                  : STD_LOGIC := '0';
70 
  CONSTANT c_sl1                  : STD_LOGIC := '1';
71 
  CONSTANT c_unsigned_0           : UNSIGNED(0 DOWNTO 0) := TO_UNSIGNED(0,1);
72 
  CONSTANT c_unsigned_1           : UNSIGNED(0 DOWNTO 0) := TO_UNSIGNED(1,1);
73 
  CONSTANT c_signed_0             : SIGNED(1 DOWNTO 0) := TO_SIGNED(0,2);
74 
  CONSTANT c_signed_1             : SIGNED(1 DOWNTO 0) := TO_SIGNED(1,2);
75 
  CONSTANT c_slv0                 : STD_LOGIC_VECTOR(255 DOWNTO 0) := (OTHERS=>'0');
76 
  CONSTANT c_slv1                 : STD_LOGIC_VECTOR(255 DOWNTO 0) := (OTHERS=>'1');
77 
  CONSTANT c_word_01              : STD_LOGIC_VECTOR(31 DOWNTO 0) := "01010101010101010101010101010101";
78 
  CONSTANT c_word_10              : STD_LOGIC_VECTOR(31 DOWNTO 0) := "10101010101010101010101010101010";
79 
  CONSTANT c_slv01                : STD_LOGIC_VECTOR(255 DOWNTO 0) := c_word_01 & c_word_01 & c_word_01 & c_word_01 & c_word_01 & c_word_01 & c_word_01 & c_word_01;
80 
  CONSTANT c_slv10                : STD_LOGIC_VECTOR(255 DOWNTO 0) := c_word_10 & c_word_10 & c_word_10 & c_word_10 & c_word_10 & c_word_10 & c_word_10 & c_word_10;
81 
 
82 
  -- math
83 
  CONSTANT c_nof_complex          : NATURAL := 2;   -- Real and imaginary part of complex number
84 
  CONSTANT c_sign_w               : NATURAL := 1;   -- Sign bit, can be used to skip one of the double sign bits of a product
85 
  CONSTANT c_sum_of_prod_w        : NATURAL := 1;   -- Bit growth for sum of 2 products, can be used in case complex multiply has normalized real and imag inputs instead of normalized amplitude inputs
86 
 
87 
  -- FF, block RAM, FIFO
88 
  CONSTANT c_meta_delay_len       : NATURAL := 3;   -- default nof flipflops (FF) in meta stability recovery delay line (e.g. for clock domain crossing)
89 
  CONSTANT c_meta_fifo_depth      : NATURAL := 16;  -- default use 16 word deep FIFO to cross clock domain, typically > 2*c_meta_delay_len or >~ 8 is enough
90 
 
91 
  CONSTANT c_bram_m9k_nof_bits    : NATURAL := 1024*9;  -- size of 1 Altera M9K block RAM in bits
92 
  CONSTANT c_bram_m9k_max_w       : NATURAL := 36;      -- maximum width of 1 Altera M9K block RAM, so the size is then 256 words of 36 bits
93 
  CONSTANT c_bram_m9k_fifo_depth  : NATURAL := c_bram_m9k_nof_bits/c_bram_m9k_max_w;  -- using a smaller FIFO depth than this leaves part of the RAM unused
94 
 
95 
  CONSTANT c_fifo_afull_margin    : NATURAL := 4;       -- default or minimal FIFO almost full margin
96 
 
97 
  -- DSP
98 
  CONSTANT c_dsp_mult_w           : NATURAL := 18;   -- Width of the embedded multipliers in Stratix IV
99 
 
100 
  -- TYPE DECLARATIONS --------------------------------------------------------
101 
  TYPE t_boolean_arr     IS ARRAY (INTEGER RANGE <>) OF BOOLEAN;   -- INTEGER left index starts default at -2**31
102 
  TYPE t_integer_arr     IS ARRAY (INTEGER RANGE <>) OF INTEGER;   -- INTEGER left index starts default at -2**31
103 
  TYPE t_natural_arr     IS ARRAY (INTEGER RANGE <>) OF NATURAL;   -- INTEGER left index starts default at -2**31
104 
  TYPE t_nat_boolean_arr IS ARRAY (NATURAL RANGE <>) OF BOOLEAN;   -- NATURAL left index starts default at 0
105 
  TYPE t_nat_integer_arr IS ARRAY (NATURAL RANGE <>) OF INTEGER;   -- NATURAL left index starts default at 0
106 
  TYPE t_nat_natural_arr IS ARRAY (NATURAL RANGE <>) OF NATURAL;   -- NATURAL left index starts default at 0
107 
  TYPE t_sl_arr          IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC;
108 
  TYPE t_slv_1_arr       IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC_VECTOR(0 DOWNTO 0);
109 
  TYPE t_slv_2_arr       IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC_VECTOR(1 DOWNTO 0);
110 
  TYPE t_slv_4_arr       IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC_VECTOR(3 DOWNTO 0);
111 
  TYPE t_slv_8_arr       IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC_VECTOR(7 DOWNTO 0);
112 
  TYPE t_slv_12_arr      IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC_VECTOR(11 DOWNTO 0);
113 
  TYPE t_slv_16_arr      IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC_VECTOR(15 DOWNTO 0);
114 
  TYPE t_slv_18_arr      IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC_VECTOR(17 DOWNTO 0);
115 
  TYPE t_slv_24_arr      IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC_VECTOR(23 DOWNTO 0);
116 
  TYPE t_slv_32_arr      IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC_VECTOR(31 DOWNTO 0);
117 
  TYPE t_slv_44_arr      IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC_VECTOR(43 DOWNTO 0);
118 
  TYPE t_slv_48_arr      IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC_VECTOR(47 DOWNTO 0);
119 
  TYPE t_slv_64_arr      IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC_VECTOR(63 DOWNTO 0);
120 
  TYPE t_slv_128_arr     IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC_VECTOR(127 DOWNTO 0);
121 
  TYPE t_slv_256_arr     IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC_VECTOR(255 DOWNTO 0);
122 
  TYPE t_slv_512_arr     IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC_VECTOR(511 DOWNTO 0);
123 
  TYPE t_slv_1024_arr    IS ARRAY (INTEGER RANGE <>) OF STD_LOGIC_VECTOR(1023 DOWNTO 0);
124 
 
125 
  CONSTANT c_boolean_arr     : t_boolean_arr     := (TRUE, FALSE);  -- array all possible values that can be iterated over
126 
  CONSTANT c_nat_boolean_arr : t_nat_boolean_arr := (TRUE, FALSE);  -- array all possible values that can be iterated over
127 
 
128 
  TYPE t_integer_matrix IS ARRAY (INTEGER RANGE <>, INTEGER RANGE <>) OF INTEGER;
129 
  TYPE t_boolean_matrix IS ARRAY (INTEGER RANGE <>, INTEGER RANGE <>) OF BOOLEAN;
130 
  TYPE t_sl_matrix      IS ARRAY (INTEGER RANGE <>, INTEGER RANGE <>) OF STD_LOGIC;
131 
  TYPE t_slv_8_matrix   IS ARRAY (INTEGER RANGE <>, INTEGER RANGE <>) OF STD_LOGIC_VECTOR(7 DOWNTO 0);
132 
  TYPE t_slv_16_matrix  IS ARRAY (INTEGER RANGE <>, INTEGER RANGE <>) OF STD_LOGIC_VECTOR(15 DOWNTO 0);
133 
  TYPE t_slv_32_matrix  IS ARRAY (INTEGER RANGE <>, INTEGER RANGE <>) OF STD_LOGIC_VECTOR(31 DOWNTO 0);
134 
  TYPE t_slv_64_matrix  IS ARRAY (INTEGER RANGE <>, INTEGER RANGE <>) OF STD_LOGIC_VECTOR(63 DOWNTO 0);
135 
 
136 
  TYPE t_natural_2arr_2 IS ARRAY (INTEGER RANGE <>) OF t_natural_arr(1 DOWNTO 0);
137 
 
138 
  -- STRUCTURE DECLARATIONS ---------------------------------------------------
139 
 
140 
  -- Clock and Reset
141 
  --
142 
  -- . rst   = Reset. Can be used asynchronously to take effect immediately
143 
  --           when used before the clk'EVENT section. May also be used as
144 
  --           synchronous reset using it as first condition in the clk'EVENT
145 
  --           section. As synchronous reset it requires clock activity to take
146 
  --           effect. A synchronous rst may or may not depend on clken,
147 
  --           however typically rst should take priority over clken.
148 
  -- . clk   = Clock. Used in clk'EVENT line via rising_edge(clk) or sometimes
149 
  --           as falling_edge(clk).
150 
  -- . clken = Clock Enable. Used for the whole clk'EVENT section.
151 
  TYPE t_sys_rce IS RECORD
152 
    rst   : STD_LOGIC;
153 
    clk   : STD_LOGIC;
154 
    clken : STD_LOGIC;  -- := '1';
155 
  END RECORD;
156 
 
157 
  TYPE t_sys_ce IS RECORD
158 
    clk   : STD_LOGIC;
159 
    clken : STD_LOGIC;  -- := '1';
160 
  END RECORD;
161 
 
162 
 
163 
  -- FUNCTION DECLARATIONS ----------------------------------------------------
164 
 
165 
  -- All functions assume [high downto low] input ranges
166 
 
167 
  FUNCTION pow2(n : NATURAL) RETURN NATURAL;  -- = 2**n
168 
  FUNCTION ceil_pow2(n : INTEGER) RETURN NATURAL;  -- = 2**n, returns 1 for n<0
169 
 
170 
  FUNCTION true_log2(n : NATURAL) RETURN NATURAL;  -- true_log2(n) = log2(n)
171 
  FUNCTION ceil_log2(n : NATURAL) RETURN NATURAL;  -- ceil_log2(n) = log2(n), but force ceil_log2(1) = 1
172 
 
173 
  FUNCTION floor_log10(n : NATURAL) RETURN NATURAL;
174 
 
175 
  FUNCTION is_pow2(n : NATURAL) RETURN BOOLEAN;        -- return TRUE when n is a power of 2, so 0, 1, 2, 4, 8, 16, ...
176 
  FUNCTION true_log_pow2(n : NATURAL) RETURN NATURAL;  -- 2**true_log2(n), return power of 2 that is >= n
177 
 
178 
  FUNCTION ratio( n, d : NATURAL) RETURN NATURAL;  -- return n/d when n MOD d = 0 else return 0, so ratio * d = n only when integer ratio > 0
179 
  FUNCTION ratio2(n, m : NATURAL) RETURN NATURAL;  -- return integer ratio of n/m or m/n, whichever is the largest
180 
 
181 
  FUNCTION ceil_div(   n, d : NATURAL)  RETURN NATURAL;   -- ceil_div    = n/d + (n MOD d)/=0
182 
  FUNCTION ceil_value( n, d : NATURAL)  RETURN NATURAL;   -- ceil_value  = ceil_div(n, d) * d
183 
  FUNCTION floor_value(n, d : NATURAL)  RETURN NATURAL;   -- floor_value = (n/d) * d
184 
  FUNCTION ceil_div(   n : UNSIGNED; d: NATURAL) RETURN UNSIGNED;
185 
  FUNCTION ceil_value( n : UNSIGNED; d: NATURAL) RETURN UNSIGNED;
186 
  FUNCTION floor_value(n : UNSIGNED; d: NATURAL) RETURN UNSIGNED;
187 
 
188 
  FUNCTION slv(n: IN STD_LOGIC)        RETURN STD_LOGIC_VECTOR;  -- standard logic to 1 element standard logic vector
189 
  FUNCTION sl( n: IN STD_LOGIC_VECTOR) RETURN STD_LOGIC;         -- 1 element standard logic vector to standard logic
190 
 
191 
  FUNCTION to_natural_arr(n : t_integer_arr; to_zero : BOOLEAN) RETURN t_natural_arr;  -- if to_zero=TRUE then negative numbers are forced to zero, otherwise they will give a compile range error
192 
  FUNCTION to_natural_arr(n : t_nat_natural_arr)                RETURN t_natural_arr;
193 
  FUNCTION to_integer_arr(n : t_natural_arr)                    RETURN t_integer_arr;
194 
  FUNCTION to_integer_arr(n : t_nat_natural_arr)                RETURN t_integer_arr;
195 
  FUNCTION to_slv_32_arr( n : t_integer_arr)                    RETURN t_slv_32_arr;
196 
  FUNCTION to_slv_32_arr( n : t_natural_arr)                    RETURN t_slv_32_arr;
197 
 
198 
  FUNCTION vector_tree(slv : STD_LOGIC_VECTOR; operation : STRING) RETURN STD_LOGIC;  -- Core operation tree function for vector "AND", "OR", "XOR"
199 
  FUNCTION vector_and(slv : STD_LOGIC_VECTOR) RETURN STD_LOGIC;  -- '1' when all slv bits are '1' else '0'
200 
  FUNCTION vector_or( slv : STD_LOGIC_VECTOR) RETURN STD_LOGIC;  -- '0' when all slv bits are '0' else '1'
201 
  FUNCTION vector_xor(slv : STD_LOGIC_VECTOR) RETURN STD_LOGIC;  -- '1' when the slv has an odd number of '1' bits else '0'
202 
  FUNCTION vector_one_hot(slv : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR; -- Returns slv when it contains one hot bit, else returns 0.
203 
 
204 
  FUNCTION andv(slv : STD_LOGIC_VECTOR) RETURN STD_LOGIC;  -- alias of vector_and
205 
  FUNCTION orv( slv : STD_LOGIC_VECTOR) RETURN STD_LOGIC;  -- alias of vector_or
206 
  FUNCTION xorv(slv : STD_LOGIC_VECTOR) RETURN STD_LOGIC;  -- alias of vector_xor
207 
 
208 
  FUNCTION matrix_and(mat : t_sl_matrix; wi, wj : NATURAL) RETURN STD_LOGIC;  -- '1' when all matrix bits are '1' else '0'
209 
  FUNCTION matrix_or( mat : t_sl_matrix; wi, wj : NATURAL) RETURN STD_LOGIC;  -- '0' when all matrix bits are '0' else '1'
210 
 
211 
  FUNCTION smallest(n, m    : INTEGER)       RETURN INTEGER;
212 
  FUNCTION smallest(n, m, l : INTEGER)       RETURN INTEGER;
213 
  FUNCTION smallest(n       : t_natural_arr) RETURN NATURAL;
214 
 
215 
  FUNCTION largest(n, m : INTEGER)       RETURN INTEGER;
216 
  FUNCTION largest(n    : t_natural_arr) RETURN NATURAL;
217 
 
218 
  FUNCTION func_sum(    n : t_natural_arr)     RETURN NATURAL;      -- sum     of all elements in array
219 
  FUNCTION func_sum(    n : t_nat_natural_arr) RETURN NATURAL;
220 
  FUNCTION func_product(n : t_natural_arr)     RETURN NATURAL;      -- product of all elements in array
221 
  FUNCTION func_product(n : t_nat_natural_arr) RETURN NATURAL;
222 
 
223 
  FUNCTION "+" (L, R: t_natural_arr)               RETURN t_natural_arr;  -- element wise sum
224 
  FUNCTION "+" (L   : t_natural_arr; R : INTEGER)  RETURN t_natural_arr;  -- element wise sum
225 
  FUNCTION "+" (L   : INTEGER; R : t_natural_arr)  RETURN t_natural_arr;  -- element wise sum
226 
 
227 
  FUNCTION "-" (L, R: t_natural_arr)               RETURN t_natural_arr;  -- element wise subtract
228 
  FUNCTION "-" (L, R: t_natural_arr)               RETURN t_integer_arr;  -- element wise subtract, support negative result
229 
  FUNCTION "-" (L   : t_natural_arr; R : INTEGER)  RETURN t_natural_arr;  -- element wise subtract
230 
  FUNCTION "-" (L   : INTEGER; R : t_natural_arr)  RETURN t_natural_arr;  -- element wise subtract
231 
 
232 
  FUNCTION "*" (L, R: t_natural_arr)               RETURN t_natural_arr;  -- element wise product
233 
  FUNCTION "*" (L   : t_natural_arr; R : NATURAL)  RETURN t_natural_arr;  -- element wise product
234 
  FUNCTION "*" (L   : NATURAL; R : t_natural_arr)  RETURN t_natural_arr;  -- element wise product
235 
 
236 
  FUNCTION "/" (L, R: t_natural_arr)               RETURN t_natural_arr;  -- element wise division
237 
  FUNCTION "/" (L   : t_natural_arr; R : POSITIVE) RETURN t_natural_arr;  -- element wise division
238 
  FUNCTION "/" (L   : NATURAL; R : t_natural_arr)  RETURN t_natural_arr;  -- element wise division
239 
 
240 
  FUNCTION is_true(a : STD_LOGIC) RETURN BOOLEAN;
241 
  FUNCTION is_true(a : STD_LOGIC) RETURN NATURAL;
242 
  FUNCTION is_true(a : BOOLEAN)   RETURN STD_LOGIC;
243 
  FUNCTION is_true(a : BOOLEAN)   RETURN NATURAL;
244 
  FUNCTION is_true(a : INTEGER)   RETURN BOOLEAN;    -- also covers NATURAL because it is a subtype of INTEGER
245 
  FUNCTION is_true(a : INTEGER)   RETURN STD_LOGIC;  -- also covers NATURAL because it is a subtype of INTEGER
246 
 
247 
  FUNCTION sel_a_b(sel,           a, b : BOOLEAN)           RETURN BOOLEAN;
248 
  FUNCTION sel_a_b(sel,           a, b : INTEGER)           RETURN INTEGER;
249 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : INTEGER)           RETURN INTEGER;
250 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : REAL)              RETURN REAL;
251 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : STD_LOGIC)         RETURN STD_LOGIC;
252 
  FUNCTION sel_a_b(sel : INTEGER; a, b : STD_LOGIC)         RETURN STD_LOGIC;
253 
  FUNCTION sel_a_b(sel : INTEGER; a, b : STD_LOGIC_VECTOR)  RETURN STD_LOGIC_VECTOR;
254 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : STD_LOGIC_VECTOR)  RETURN STD_LOGIC_VECTOR;
255 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : SIGNED)            RETURN SIGNED;
256 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : UNSIGNED)          RETURN UNSIGNED;
257 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : t_integer_arr)     RETURN t_integer_arr;
258 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : t_natural_arr)     RETURN t_natural_arr;
259 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : t_nat_integer_arr) RETURN t_nat_integer_arr;
260 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : t_nat_natural_arr) RETURN t_nat_natural_arr;
261 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : STRING)            RETURN STRING;
262 
  FUNCTION sel_a_b(sel : INTEGER; a, b : STRING)            RETURN STRING;
263 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : TIME)              RETURN TIME;
264 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : SEVERITY_LEVEL)    RETURN SEVERITY_LEVEL;
265 
 
266 
  -- sel_n() index sel = 0, 1, 2, ... will return a, b, c, ...
267 
  FUNCTION sel_n(sel : NATURAL; a, b, c                      : BOOLEAN) RETURN BOOLEAN;  --  3
268 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d                   : BOOLEAN) RETURN BOOLEAN;  --  4
269 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e                : BOOLEAN) RETURN BOOLEAN;  --  5
270 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f             : BOOLEAN) RETURN BOOLEAN;  --  6
271 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g          : BOOLEAN) RETURN BOOLEAN;  --  7
272 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h       : BOOLEAN) RETURN BOOLEAN;  --  8
273 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h, i    : BOOLEAN) RETURN BOOLEAN;  --  9
274 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h, i, j : BOOLEAN) RETURN BOOLEAN;  -- 10
275 
 
276 
  FUNCTION sel_n(sel : NATURAL; a, b, c                      : INTEGER) RETURN INTEGER;  --  3
277 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d                   : INTEGER) RETURN INTEGER;  --  4
278 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e                : INTEGER) RETURN INTEGER;  --  5
279 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f             : INTEGER) RETURN INTEGER;  --  6
280 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g          : INTEGER) RETURN INTEGER;  --  7
281 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h       : INTEGER) RETURN INTEGER;  --  8
282 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h, i    : INTEGER) RETURN INTEGER;  --  9
283 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h, i, j : INTEGER) RETURN INTEGER;  -- 10
284 
 
285 
  FUNCTION sel_n(sel : NATURAL; a, b                         : STRING) RETURN STRING;    --  2
286 
  FUNCTION sel_n(sel : NATURAL; a, b, c                      : STRING) RETURN STRING;    --  3
287 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d                   : STRING) RETURN STRING;    --  4
288 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e                : STRING) RETURN STRING;    --  5
289 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f             : STRING) RETURN STRING;    --  6
290 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g          : STRING) RETURN STRING;    --  7
291 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h       : STRING) RETURN STRING;    --  8
292 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h, i    : STRING) RETURN STRING;    --  9
293 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h, i, j : STRING) RETURN STRING;    -- 10
294 
 
295 
  FUNCTION array_init(init : STD_LOGIC; nof              : NATURAL) RETURN STD_LOGIC_VECTOR;  -- useful to init a unconstrained array of size 1
296 
  FUNCTION array_init(init,             nof              : NATURAL) RETURN t_natural_arr;     -- useful to init a unconstrained array of size 1
297 
  FUNCTION array_init(init,             nof              : NATURAL) RETURN t_nat_natural_arr; -- useful to init a unconstrained array of size 1
298 
  FUNCTION array_init(init,             nof, incr        : NATURAL) RETURN t_natural_arr;     -- useful to init an array with incrementing numbers
299 
  FUNCTION array_init(init,             nof, incr        : NATURAL) RETURN t_nat_natural_arr;
300 
  FUNCTION array_init(init,             nof, incr        : INTEGER) RETURN t_slv_16_arr;
301 
  FUNCTION array_init(init,             nof, incr        : INTEGER) RETURN t_slv_32_arr;
302 
  FUNCTION array_init(init,             nof, width       : NATURAL) RETURN STD_LOGIC_VECTOR;  -- useful to init an unconstrained std_logic_vector with repetitive content
303 
  FUNCTION array_init(init,             nof, width, incr : NATURAL) RETURN STD_LOGIC_VECTOR;  -- useful to init an unconstrained std_logic_vector with incrementing content
304 
  FUNCTION array_sinit(init : INTEGER;   nof, width       : NATURAL) RETURN STD_LOGIC_VECTOR;  -- useful to init an unconstrained std_logic_vector with repetitive content
305 
 
306 
  FUNCTION init_slv_64_matrix(nof_a, nof_b, k : INTEGER) RETURN t_slv_64_matrix;  -- initialize all elements in t_slv_64_matrix to value k
307 
 
308 
  -- Concatenate two or more STD_LOGIC_VECTORs into a single STD_LOGIC_VECTOR or extract one of them from a concatenated STD_LOGIC_VECTOR
309 
  FUNCTION func_slv_concat(  use_a, use_b, use_c, use_d, use_e, use_f, use_g : BOOLEAN; a, b, c, d, e, f, g : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR;
310 
  FUNCTION func_slv_concat(  use_a, use_b, use_c, use_d, use_e, use_f        : BOOLEAN; a, b, c, d, e, f    : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR;
311 
  FUNCTION func_slv_concat(  use_a, use_b, use_c, use_d, use_e               : BOOLEAN; a, b, c, d, e       : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR;
312 
  FUNCTION func_slv_concat(  use_a, use_b, use_c, use_d                      : BOOLEAN; a, b, c, d          : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR;
313 
  FUNCTION func_slv_concat(  use_a, use_b, use_c                             : BOOLEAN; a, b, c             : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR;
314 
  FUNCTION func_slv_concat(  use_a, use_b                                    : BOOLEAN; a, b                : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR;
315 
  FUNCTION func_slv_concat_w(use_a, use_b, use_c, use_d, use_e, use_f, use_g : BOOLEAN; a_w, b_w, c_w, d_w, e_w, f_w, g_w : NATURAL) RETURN NATURAL;
316 
  FUNCTION func_slv_concat_w(use_a, use_b, use_c, use_d, use_e, use_f        : BOOLEAN; a_w, b_w, c_w, d_w, e_w, f_w      : NATURAL) RETURN NATURAL;
317 
  FUNCTION func_slv_concat_w(use_a, use_b, use_c, use_d, use_e               : BOOLEAN; a_w, b_w, c_w, d_w, e_w           : NATURAL) RETURN NATURAL;
318 
  FUNCTION func_slv_concat_w(use_a, use_b, use_c, use_d                      : BOOLEAN; a_w, b_w, c_w, d_w                : NATURAL) RETURN NATURAL;
319 
  FUNCTION func_slv_concat_w(use_a, use_b, use_c                             : BOOLEAN; a_w, b_w, c_w                     : NATURAL) RETURN NATURAL;
320 
  FUNCTION func_slv_concat_w(use_a, use_b                                    : BOOLEAN; a_w, b_w                          : NATURAL) RETURN NATURAL;
321 
  FUNCTION func_slv_extract( use_a, use_b, use_c, use_d, use_e, use_f, use_g : BOOLEAN; a_w, b_w, c_w, d_w, e_w, f_w, g_w : NATURAL; vec : STD_LOGIC_VECTOR; sel : NATURAL) RETURN STD_LOGIC_VECTOR;
322 
  FUNCTION func_slv_extract( use_a, use_b, use_c, use_d, use_e, use_f        : BOOLEAN; a_w, b_w, c_w, d_w, e_w, f_w      : NATURAL; vec : STD_LOGIC_VECTOR; sel : NATURAL) RETURN STD_LOGIC_VECTOR;
323 
  FUNCTION func_slv_extract( use_a, use_b, use_c, use_d, use_e               : BOOLEAN; a_w, b_w, c_w, d_w, e_w           : NATURAL; vec : STD_LOGIC_VECTOR; sel : NATURAL) RETURN STD_LOGIC_VECTOR;
324 
  FUNCTION func_slv_extract( use_a, use_b, use_c, use_d                      : BOOLEAN; a_w, b_w, c_w, d_w                : NATURAL; vec : STD_LOGIC_VECTOR; sel : NATURAL) RETURN STD_LOGIC_VECTOR;
325 
  FUNCTION func_slv_extract( use_a, use_b, use_c                             : BOOLEAN; a_w, b_w, c_w                     : NATURAL; vec : STD_LOGIC_VECTOR; sel : NATURAL) RETURN STD_LOGIC_VECTOR;
326 
  FUNCTION func_slv_extract( use_a, use_b                                    : BOOLEAN; a_w, b_w                          : NATURAL; vec : STD_LOGIC_VECTOR; sel : NATURAL) RETURN STD_LOGIC_VECTOR;
327 
 
328 
  FUNCTION TO_UINT(vec : STD_LOGIC_VECTOR) RETURN NATURAL;  -- beware: NATURAL'HIGH = 2**31-1, not 2*32-1, use TO_SINT to avoid warning
329 
  FUNCTION TO_SINT(vec : STD_LOGIC_VECTOR) RETURN INTEGER;
330 
 
331 
  FUNCTION TO_UVEC(dec, w : NATURAL) RETURN STD_LOGIC_VECTOR;
332 
  FUNCTION TO_SVEC(dec, w : INTEGER) RETURN STD_LOGIC_VECTOR;
333 
 
334 
  FUNCTION TO_SVEC_32(dec : INTEGER) RETURN STD_LOGIC_VECTOR;  -- = TO_SVEC() with w=32 for t_slv_32_arr slv elements
335 
 
336 
-- The RESIZE for SIGNED in IEEE.NUMERIC_STD extends the sign bit or it keeps the sign bit and LS part. This
337 
  -- behaviour of preserving the sign bit is less suitable for DSP and not necessary in general. A more
338 
  -- appropriate approach is to ignore the MSbit sign and just keep the LS part. For too large values this
339 
  -- means that the result gets wrapped, but that is fine for default behaviour, because that is also what
340 
  -- happens for RESIZE of UNSIGNED. Therefor this is what the RESIZE_NUM for SIGNED and the RESIZE_SVEC do
341 
  -- and better not use RESIZE for SIGNED anymore.
342 
  FUNCTION RESIZE_NUM( u   : UNSIGNED;         w : NATURAL) RETURN UNSIGNED;          -- left extend with '0' or keep LS part (same as RESIZE for UNSIGNED)
343 
  FUNCTION RESIZE_NUM( s   : SIGNED;           w : NATURAL) RETURN SIGNED;            -- extend sign bit or keep LS part
344 
  FUNCTION RESIZE_UVEC(sl  : STD_LOGIC;        w : NATURAL) RETURN STD_LOGIC_VECTOR;  -- left extend with '0' into slv
345 
  FUNCTION RESIZE_UVEC(vec : STD_LOGIC_VECTOR; w : NATURAL) RETURN STD_LOGIC_VECTOR;  -- left extend with '0' or keep LS part
346 
  FUNCTION RESIZE_SVEC(vec : STD_LOGIC_VECTOR; w : NATURAL) RETURN STD_LOGIC_VECTOR;  -- extend sign bit or keep LS part
347 
  FUNCTION RESIZE_UINT(u   : INTEGER;          w : NATURAL) RETURN INTEGER;           -- left extend with '0' or keep LS part
348 
  FUNCTION RESIZE_SINT(s   : INTEGER;          w : NATURAL) RETURN INTEGER;           -- extend sign bit or keep LS part
349 
 
350 
  FUNCTION RESIZE_UVEC_32(vec : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR;  -- = RESIZE_UVEC() with w=32 for t_slv_32_arr slv elements
351 
  FUNCTION RESIZE_SVEC_32(vec : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR;  -- = RESIZE_SVEC() with w=32 for t_slv_32_arr slv elements
352 
 
353 
  FUNCTION INCR_UVEC(vec : STD_LOGIC_VECTOR; dec : INTEGER)  RETURN STD_LOGIC_VECTOR;
354 
  FUNCTION INCR_UVEC(vec : STD_LOGIC_VECTOR; dec : UNSIGNED) RETURN STD_LOGIC_VECTOR;
355 
  FUNCTION INCR_SVEC(vec : STD_LOGIC_VECTOR; dec : INTEGER)  RETURN STD_LOGIC_VECTOR;
356 
  FUNCTION INCR_SVEC(vec : STD_LOGIC_VECTOR; dec : SIGNED)   RETURN STD_LOGIC_VECTOR;
357 
                                                                                                                   -- Used in common_add_sub.vhd
358 
  FUNCTION ADD_SVEC(l_vec : STD_LOGIC_VECTOR; r_vec : STD_LOGIC_VECTOR; res_w : NATURAL) RETURN STD_LOGIC_VECTOR;  -- l_vec + r_vec, treat slv operands as signed,   slv output width is res_w
359 
  FUNCTION SUB_SVEC(l_vec : STD_LOGIC_VECTOR; r_vec : STD_LOGIC_VECTOR; res_w : NATURAL) RETURN STD_LOGIC_VECTOR;  -- l_vec - r_vec, treat slv operands as signed,   slv output width is res_w
360 
  FUNCTION ADD_UVEC(l_vec : STD_LOGIC_VECTOR; r_vec : STD_LOGIC_VECTOR; res_w : NATURAL) RETURN STD_LOGIC_VECTOR;  -- l_vec + r_vec, treat slv operands as unsigned, slv output width is res_w
361 
  FUNCTION SUB_UVEC(l_vec : STD_LOGIC_VECTOR; r_vec : STD_LOGIC_VECTOR; res_w : NATURAL) RETURN STD_LOGIC_VECTOR;  -- l_vec - r_vec, treat slv operands as unsigned, slv output width is res_w
362 
 
363 
  FUNCTION ADD_SVEC(l_vec : STD_LOGIC_VECTOR; r_vec : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR;                   -- l_vec + r_vec, treat slv operands as signed,   slv output width is l_vec'LENGTH
364 
  FUNCTION SUB_SVEC(l_vec : STD_LOGIC_VECTOR; r_vec : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR;                   -- l_vec - r_vec, treat slv operands as signed,   slv output width is l_vec'LENGTH
365 
  FUNCTION ADD_UVEC(l_vec : STD_LOGIC_VECTOR; r_vec : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR;                   -- l_vec + r_vec, treat slv operands as unsigned, slv output width is l_vec'LENGTH
366 
  FUNCTION SUB_UVEC(l_vec : STD_LOGIC_VECTOR; r_vec : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR;                   -- l_vec - r_vec, treat slv operands as unsigned, slv output width is l_vec'LENGTH
367 
 
368 
  FUNCTION COMPLEX_MULT_REAL(a_re, a_im, b_re, b_im : INTEGER) RETURN INTEGER;  -- Calculate real part of complex multiplication: a_re*b_re - a_im*b_im
369 
  FUNCTION COMPLEX_MULT_IMAG(a_re, a_im, b_re, b_im : INTEGER) RETURN INTEGER;  -- Calculate imag part of complex multiplication: a_im*b_re + a_re*b_im
370 
 
371 
  FUNCTION SHIFT_UVEC(vec : STD_LOGIC_VECTOR; shift : INTEGER) RETURN STD_LOGIC_VECTOR;  -- < 0 shift left, > 0 shift right
372 
  FUNCTION SHIFT_SVEC(vec : STD_LOGIC_VECTOR; shift : INTEGER) RETURN STD_LOGIC_VECTOR;  -- < 0 shift left, > 0 shift right
373 
 
374 
  FUNCTION offset_binary(a : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR;
375 
 
376 
  FUNCTION truncate(                vec : STD_LOGIC_VECTOR; n              : NATURAL) RETURN STD_LOGIC_VECTOR;  -- remove n LSBits from vec, so result has width vec'LENGTH-n
377 
  FUNCTION truncate_and_resize_uvec(vec : STD_LOGIC_VECTOR; n,           w : NATURAL) RETURN STD_LOGIC_VECTOR;  -- remove n LSBits from vec and then resize to width w
378 
  FUNCTION truncate_and_resize_svec(vec : STD_LOGIC_VECTOR; n,           w : NATURAL) RETURN STD_LOGIC_VECTOR;  -- idem for signed values
379 
  FUNCTION scale(                   vec : STD_LOGIC_VECTOR; n:               NATURAL) RETURN STD_LOGIC_VECTOR;  -- add n '0' LSBits to vec
380 
  FUNCTION scale_and_resize_uvec(   vec : STD_LOGIC_VECTOR; n,           w : NATURAL) RETURN STD_LOGIC_VECTOR;  -- add n '0' LSBits to vec and then resize to width w
381 
  FUNCTION scale_and_resize_svec(   vec : STD_LOGIC_VECTOR; n,           w : NATURAL) RETURN STD_LOGIC_VECTOR;  -- idem for signed values
382 
  FUNCTION truncate_or_resize_uvec( vec : STD_LOGIC_VECTOR; b : BOOLEAN; w : NATURAL) RETURN STD_LOGIC_VECTOR;  -- when b=TRUE then truncate to width w, else resize to width w
383 
  FUNCTION truncate_or_resize_svec( vec : STD_LOGIC_VECTOR; b : BOOLEAN; w : NATURAL) RETURN STD_LOGIC_VECTOR;  -- idem for signed values
384 
 
385 
  FUNCTION s_round(   vec : STD_LOGIC_VECTOR; n : NATURAL; clip : BOOLEAN) RETURN STD_LOGIC_VECTOR;  -- remove n LSBits from vec by rounding away from 0, so result has width vec'LENGTH-n, and clip to avoid wrap
386 
  FUNCTION s_round(   vec : STD_LOGIC_VECTOR; n : NATURAL)                 RETURN STD_LOGIC_VECTOR;  -- remove n LSBits from vec by rounding away from 0, so result has width vec'LENGTH-n
387 
  FUNCTION s_round_up(vec : STD_LOGIC_VECTOR; n : NATURAL; clip : BOOLEAN) RETURN STD_LOGIC_VECTOR;  -- idem but round up to +infinity (s_round_up = u_round)
388 
  FUNCTION s_round_up(vec : STD_LOGIC_VECTOR; n : NATURAL)                 RETURN STD_LOGIC_VECTOR;  -- idem but round up to +infinity (s_round_up = u_round)
389 
  FUNCTION u_round(   vec : STD_LOGIC_VECTOR; n : NATURAL; clip : BOOLEAN) RETURN STD_LOGIC_VECTOR;  -- idem round up for unsigned values
390 
  FUNCTION u_round(   vec : STD_LOGIC_VECTOR; n : NATURAL)                 RETURN STD_LOGIC_VECTOR;  -- idem round up for unsigned values
391 
 
392 9 danv 
  FUNCTION u_to_s(u : NATURAL; w : NATURAL) RETURN INTEGER;   -- interpret w bit unsigned u as w bit   signed, and remove any MSbits
393 
  FUNCTION s_to_u(s : INTEGER; w : NATURAL) RETURN NATURAL;   -- interpret w bit   signed s as w bit unsigned, and remove any MSbits
394 
 
395 
  FUNCTION u_wrap(u : NATURAL; w : NATURAL) RETURN NATURAL;   -- return u & 2**w-1 (bit wise and), so keep w LSbits of unsigned u, and remove MSbits
396 
  FUNCTION s_wrap(s : INTEGER; w : NATURAL) RETURN INTEGER;   -- return s & 2**w-1 (bit wise and), so keep w LSbits of   signed s, and remove MSbits
397 
 
398 
  FUNCTION u_clip(u : NATURAL; max : NATURAL) RETURN NATURAL;                  -- if s < max return s, else return n
399 
  FUNCTION s_clip(s : INTEGER; max : NATURAL; min : INTEGER) RETURN INTEGER;   -- if s <=  min return  min, else if s >= max return max, else return s
400 
  FUNCTION s_clip(s : INTEGER; max : NATURAL               ) RETURN INTEGER;   -- if s <= -max return -max, else if s >= max return max, else return s
401 
 
402 6 danv 
  FUNCTION hton(a : STD_LOGIC_VECTOR; w, sz : NATURAL) RETURN STD_LOGIC_VECTOR;  -- convert endianity from host to network, sz in symbols of width w
403 
  FUNCTION hton(a : STD_LOGIC_VECTOR;    sz : NATURAL) RETURN STD_LOGIC_VECTOR;  -- convert endianity from host to network, sz in bytes
404 
  FUNCTION hton(a : STD_LOGIC_VECTOR                 ) RETURN STD_LOGIC_VECTOR;  -- convert endianity from host to network, for all bytes in a
405 
  FUNCTION ntoh(a : STD_LOGIC_VECTOR;    sz : NATURAL) RETURN STD_LOGIC_VECTOR;  -- convert endianity from network to host, sz in bytes, ntoh() = hton()
406 
  FUNCTION ntoh(a : STD_LOGIC_VECTOR                 ) RETURN STD_LOGIC_VECTOR;  -- convert endianity from network to host, for all bytes in a, ntoh() = hton()
407 
 
408 
  FUNCTION flip(a : STD_LOGIC_VECTOR)  RETURN STD_LOGIC_VECTOR;  -- bit flip a vector, map a[h:0] to [0:h]
409 
  FUNCTION flip(a, w : NATURAL)        RETURN NATURAL;           -- bit flip a vector, map a[h:0] to [0:h], h = w-1
410 
  FUNCTION flip(a : t_slv_32_arr)      RETURN t_slv_32_arr;
411 
  FUNCTION flip(a : t_integer_arr)     RETURN t_integer_arr;
412 
  FUNCTION flip(a : t_natural_arr)     RETURN t_natural_arr;
413 
  FUNCTION flip(a : t_nat_natural_arr) RETURN t_nat_natural_arr;
414 
 
415 
  FUNCTION transpose(a : STD_LOGIC_VECTOR; row, col : NATURAL) RETURN STD_LOGIC_VECTOR;  -- transpose a vector, map a[i*row+j] to output index [j*col+i]
416 
  FUNCTION transpose(a,                    row, col : NATURAL) RETURN NATURAL;           -- transpose index a = [i*row+j] to output index [j*col+i]
417 
 
418 
  FUNCTION split_w(input_w: NATURAL; min_out_w: NATURAL; max_out_w: NATURAL) RETURN NATURAL;
419 
 
420 
  FUNCTION pad(str: STRING; width: NATURAL; pad_char: CHARACTER) RETURN STRING;
421 
 
422 
  FUNCTION slice_up(str: STRING; width: NATURAL; i: NATURAL) RETURN STRING;
423 
  FUNCTION slice_up(str: STRING; width: NATURAL; i: NATURAL; pad_char: CHARACTER) RETURN STRING;
424 
  FUNCTION slice_dn(str: STRING; width: NATURAL; i: NATURAL) RETURN STRING;
425 
 
426 
  FUNCTION nat_arr_to_concat_slv(nat_arr: t_natural_arr; nof_elements: NATURAL) RETURN STD_LOGIC_VECTOR;
427 
 
428 
  ------------------------------------------------------------------------------
429 
  -- Component specific functions
430 
  ------------------------------------------------------------------------------
431 
 
432 
  -- common_fifo_*
433 
  PROCEDURE proc_common_fifo_asserts (CONSTANT c_fifo_name   : IN STRING;
434 
                                      CONSTANT c_note_is_ful : IN BOOLEAN;
435 
                                      CONSTANT c_fail_rd_emp : IN BOOLEAN;
436 
                                      SIGNAL   wr_rst        : IN STD_LOGIC;
437 
                                      SIGNAL   wr_clk        : IN STD_LOGIC;
438 
                                      SIGNAL   wr_full       : IN STD_LOGIC;
439 
                                      SIGNAL   wr_en         : IN STD_LOGIC;
440 
                                      SIGNAL   rd_clk        : IN STD_LOGIC;
441 
                                      SIGNAL   rd_empty      : IN STD_LOGIC;
442 
                                      SIGNAL   rd_en         : IN STD_LOGIC);
443 
 
444 
  -- common_fanout_tree
445 
  FUNCTION func_common_fanout_tree_pipelining(c_nof_stages, c_nof_output_per_cell, c_nof_output : NATURAL;
446 
                                              c_cell_pipeline_factor_arr, c_cell_pipeline_arr : t_natural_arr) RETURN t_natural_arr;
447 
 
448 
  -- common_reorder_symbol
449 
  FUNCTION func_common_reorder2_is_there(I, J : NATURAL) RETURN BOOLEAN;
450 
  FUNCTION func_common_reorder2_is_active(I, J, N : NATURAL) RETURN BOOLEAN;
451 
  FUNCTION func_common_reorder2_get_select_index(I, J, N : NATURAL) RETURN INTEGER;
452 
  FUNCTION func_common_reorder2_get_select(I, J, N : NATURAL; select_arr : t_natural_arr) RETURN NATURAL;
453 
  FUNCTION func_common_reorder2_inverse_select(N : NATURAL; select_arr : t_natural_arr) RETURN t_natural_arr;
454 
 
455 
  -- Generate faster sample SCLK from digital DCLK for sim only
456 
  PROCEDURE proc_common_dclk_generate_sclk(CONSTANT Pfactor : IN    POSITIVE;
457 
                                           SIGNAL   dclk    : IN    STD_LOGIC;
458 
                                           SIGNAL   sclk    : INOUT STD_LOGIC);
459 
 
460 
END common_pkg;
461 
 
462 
PACKAGE BODY common_pkg IS
463 
 
464 
  FUNCTION pow2(n : NATURAL) RETURN NATURAL IS
465 
  BEGIN
466 
    RETURN 2**n;
467 
  END;
468 
 
469 
  FUNCTION ceil_pow2(n : INTEGER) RETURN NATURAL IS
470 
  -- Also allows negative exponents and rounds up before returning the value
471 
  BEGIN
472 
    RETURN natural(integer(ceil(2**real(n))));
473 
  END;
474 
 
475 
  FUNCTION true_log2(n : NATURAL) RETURN NATURAL IS
476 
  -- Purpose: For calculating extra vector width of existing vector
477 
  -- Description: Return mathematical ceil(log2(n))
478 
  --   n    log2()
479 
  --   0 -> -oo  --> FAILURE
480 
  --   1 ->  0
481 
  --   2 ->  1
482 
  --   3 ->  2
483 
  --   4 ->  2
484 
  --   5 ->  3
485 
  --   6 ->  3
486 
  --   7 ->  3
487 
  --   8 ->  3
488 
  --   9 ->  4
489 
  --   etc, up to n = NATURAL'HIGH = 2**31-1
490 
  BEGIN
491 
    RETURN natural(integer(ceil(log2(real(n)))));
492 
  END;
493 
 
494 
  FUNCTION ceil_log2(n : NATURAL) RETURN NATURAL IS
495 
  -- Purpose: For calculating vector width of new vector
496 
  -- Description:
497 
  --   Same as true_log2() except ceil_log2(1) = 1, which is needed to support
498 
  --   the vector width width for 1 address, to avoid NULL array for single
499 
  --   word register address.
500 
  --   If n = 0, return 0 so we get a NULL array when using
501 
  --   STD_LOGIC_VECTOR(ceil_log2(g_addr_w)-1 DOWNTO 0), instead of an error.
502 
  BEGIN
503 
    IF n = 0 THEN
504 
      RETURN 0;  -- Get NULL array
505 
    ELSIF n = 1 THEN
506 
      RETURN 1;  -- avoid NULL array
507 
    ELSE
508 
      RETURN true_log2(n);
509 
    END IF;
510 
  END;
511 
 
512 
  FUNCTION floor_log10(n : NATURAL) RETURN NATURAL IS
513 
  BEGIN
514 
    RETURN natural(integer(floor(log10(real(n)))));
515 
  END;
516 
 
517 
  FUNCTION is_pow2(n : NATURAL) RETURN BOOLEAN IS
518 
  BEGIN
519 
    RETURN n=2**true_log2(n);
520 
  END;
521 
 
522 
  FUNCTION true_log_pow2(n : NATURAL) RETURN NATURAL IS
523 
  BEGIN
524 
    RETURN 2**true_log2(n);
525 
  END;
526 
 
527 
  FUNCTION ratio(n, d : NATURAL) RETURN NATURAL IS
528 
  BEGIN
529 
    IF n MOD d = 0 THEN
530 
      RETURN n/d;
531 
    ELSE
532 
      RETURN 0;
533 
    END IF;
534 
  END;
535 
 
536 
  FUNCTION ratio2(n, m : NATURAL) RETURN NATURAL IS
537 
  BEGIN
538 
    RETURN largest(ratio(n,m), ratio(m,n));
539 
  END;
540 
 
541 
  FUNCTION ceil_div(n, d : NATURAL) RETURN NATURAL IS
542 
  BEGIN
543 
    RETURN n/d + sel_a_b(n MOD d = 0, 0, 1);
544 
  END;
545 
 
546 
  FUNCTION ceil_value(n, d : NATURAL) RETURN NATURAL IS
547 
  BEGIN
548 
    RETURN ceil_div(n, d) * d;
549 
  END;
550 
 
551 
  FUNCTION floor_value(n, d : NATURAL) RETURN NATURAL IS
552 
  BEGIN
553 
    RETURN (n / d) * d;
554 
  END;
555 
 
556 
  FUNCTION ceil_div(n : UNSIGNED; d: NATURAL) RETURN UNSIGNED IS
557 
  BEGIN
558 
    RETURN n/d + sel_a_b(n MOD d = 0, 0, 1);  -- "/" returns same width as n
559 
  END;
560 
 
561 
  FUNCTION ceil_value(n : UNSIGNED; d: NATURAL) RETURN UNSIGNED IS
562 
    CONSTANT w : NATURAL := n'LENGTH;
563 
    VARIABLE p : UNSIGNED(2*w-1 DOWNTO 0);
564 
  BEGIN
565 
    p := ceil_div(n, d) * d;
566 
    RETURN p(w-1 DOWNTO 0);  -- return same width as n
567 
  END;
568 
 
569 
  FUNCTION floor_value(n : UNSIGNED; d: NATURAL) RETURN UNSIGNED IS
570 
    CONSTANT w : NATURAL := n'LENGTH;
571 
    VARIABLE p : UNSIGNED(2*w-1 DOWNTO 0);
572 
  BEGIN
573 
    p := (n / d) * d;
574 
    RETURN p(w-1 DOWNTO 0);  -- return same width as n
575 
  END;
576 
 
577 
  FUNCTION slv(n: IN STD_LOGIC) RETURN STD_LOGIC_VECTOR IS
578 
    VARIABLE r : STD_LOGIC_VECTOR(0 DOWNTO 0);
579 
  BEGIN
580 
    r(0) := n;
581 
    RETURN r;
582 
  END;
583 
 
584 
  FUNCTION sl(n: IN STD_LOGIC_VECTOR) RETURN STD_LOGIC IS
585 
    VARIABLE r : STD_LOGIC;
586 
  BEGIN
587 
    r := n(n'LOW);
588 
    RETURN r;
589 
  END;
590 
 
591 
  FUNCTION to_natural_arr(n : t_integer_arr; to_zero : BOOLEAN) RETURN t_natural_arr IS
592 
    VARIABLE vN : t_integer_arr(n'LENGTH-1 DOWNTO 0);
593 
    VARIABLE vR : t_natural_arr(n'LENGTH-1 DOWNTO 0);
594 
  BEGIN
595 
    vN := n;
596 
    FOR I IN vN'RANGE LOOP
597 
      IF to_zero=FALSE THEN
598 
        vR(I) := vN(I);
599 
      ELSE
600 
        vR(I) := 0;
601 
        IF vN(I)>0 THEN
602 
          vR(I) := vN(I);
603 
        END IF;
604 
      END IF;
605 
    END LOOP;
606 
    RETURN vR;
607 
  END;
608 
 
609 
  FUNCTION to_natural_arr(n : t_nat_natural_arr) RETURN t_natural_arr IS
610 
    VARIABLE vN : t_nat_natural_arr(n'LENGTH-1 DOWNTO 0);
611 
    VARIABLE vR : t_natural_arr(n'LENGTH-1 DOWNTO 0);
612 
  BEGIN
613 
    vN := n;
614 
    FOR I IN vN'RANGE LOOP
615 
      vR(I) := vN(I);
616 
    END LOOP;
617 
    RETURN vR;
618 
  END;
619 
 
620 
  FUNCTION to_integer_arr(n : t_natural_arr) RETURN t_integer_arr IS
621 
    VARIABLE vN : t_natural_arr(n'LENGTH-1 DOWNTO 0);
622 
    VARIABLE vR : t_integer_arr(n'LENGTH-1 DOWNTO 0);
623 
  BEGIN
624 
    vN := n;
625 
    FOR I IN vN'RANGE LOOP
626 
      vR(I) := vN(I);
627 
    END LOOP;
628 
    RETURN vR;
629 
  END;
630 
 
631 
  FUNCTION to_integer_arr(n : t_nat_natural_arr) RETURN t_integer_arr IS
632 
    VARIABLE vN : t_natural_arr(n'LENGTH-1 DOWNTO 0);
633 
  BEGIN
634 
    vN := to_natural_arr(n);
635 
    RETURN to_integer_arr(vN);
636 
  END;
637 
 
638 
  FUNCTION to_slv_32_arr(n : t_integer_arr) RETURN t_slv_32_arr IS
639 
    VARIABLE vN : t_integer_arr(n'LENGTH-1 DOWNTO 0);
640 
    VARIABLE vR : t_slv_32_arr(n'LENGTH-1 DOWNTO 0);
641 
  BEGIN
642 
    vN := n;
643 
    FOR I IN vN'RANGE LOOP
644 
      vR(I) := TO_SVEC(vN(I), 32);
645 
    END LOOP;
646 
    RETURN vR;
647 
  END;
648 
 
649 
  FUNCTION to_slv_32_arr(n : t_natural_arr) RETURN t_slv_32_arr IS
650 
    VARIABLE vN : t_natural_arr(n'LENGTH-1 DOWNTO 0);
651 
    VARIABLE vR : t_slv_32_arr(n'LENGTH-1 DOWNTO 0);
652 
  BEGIN
653 
    vN := n;
654 
    FOR I IN vN'RANGE LOOP
655 
      vR(I) := TO_UVEC(vN(I), 32);
656 
    END LOOP;
657 
    RETURN vR;
658 
  END;
659 
 
660 
  FUNCTION vector_tree(slv : STD_LOGIC_VECTOR; operation : STRING) RETURN STD_LOGIC IS
661 
    -- Linear loop to determine result takes combinatorial delay that is proportional to slv'LENGTH:
662 
    --   FOR I IN slv'RANGE LOOP
663 
    --     v_result := v_result OPERATION slv(I);
664 
    --   END LOOP;
665 
    --   RETURN v_result;
666 
    -- Instead use binary tree to determine result with smallest combinatorial delay that depends on log2(slv'LENGTH)
667 
    CONSTANT c_slv_w      : NATURAL := slv'LENGTH;
668 
    CONSTANT c_nof_stages : NATURAL := ceil_log2(c_slv_w);
669 
    CONSTANT c_w          : NATURAL := 2**c_nof_stages;  -- extend the input slv to a vector with length power of 2 to ease using binary tree
670 
    TYPE t_stage_arr IS ARRAY (-1 TO c_nof_stages-1) OF STD_LOGIC_VECTOR(c_w-1 DOWNTO 0);
671 
    VARIABLE v_stage_arr  : t_stage_arr;
672 
    VARIABLE v_result     : STD_LOGIC := '0';
673 
  BEGIN
674 
    -- default any unused, the stage results will be kept in the LSBits and the last result in bit 0
675 
    IF    operation="AND" THEN v_stage_arr := (OTHERS=>(OTHERS=>'1'));
676 
    ELSIF operation="OR"  THEN v_stage_arr := (OTHERS=>(OTHERS=>'0'));
677 
    ELSIF operation="XOR" THEN v_stage_arr := (OTHERS=>(OTHERS=>'0'));
678 
    ELSE
679 
      ASSERT TRUE REPORT "common_pkg: Unsupported vector_tree operation" SEVERITY FAILURE;
680 
    END IF;
681 
    v_stage_arr(-1)(c_slv_w-1 DOWNTO 0) := slv;  -- any unused input c_w : c_slv_w bits have void default value
682 
    FOR J IN 0 TO c_nof_stages-1 LOOP
683 
      FOR I IN 0 TO c_w/(2**(J+1))-1 LOOP
684 
        IF    operation="AND" THEN v_stage_arr(J)(I) := v_stage_arr(J-1)(2*I) AND v_stage_arr(J-1)(2*I+1);
685 
        ELSIF operation="OR"  THEN v_stage_arr(J)(I) := v_stage_arr(J-1)(2*I) OR  v_stage_arr(J-1)(2*I+1);
686 
        ELSIF operation="XOR" THEN v_stage_arr(J)(I) := v_stage_arr(J-1)(2*I) XOR v_stage_arr(J-1)(2*I+1);
687 
        END IF;
688 
      END LOOP;
689 
    END LOOP;
690 
    RETURN v_stage_arr(c_nof_stages-1)(0);
691 
  END;
692 
 
693 
  FUNCTION vector_and(slv : STD_LOGIC_VECTOR) RETURN STD_LOGIC IS
694 
  BEGIN
695 
    RETURN vector_tree(slv, "AND");
696 
  END;
697 
 
698 
  FUNCTION vector_or(slv : STD_LOGIC_VECTOR) RETURN STD_LOGIC IS
699 
  BEGIN
700 
    RETURN vector_tree(slv, "OR");
701 
  END;
702 
 
703 
  FUNCTION vector_xor(slv : STD_LOGIC_VECTOR) RETURN STD_LOGIC IS
704 
  BEGIN
705 
    RETURN vector_tree(slv, "XOR");
706 
  END;
707 
 
708 
  FUNCTION vector_one_hot(slv : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
709 
    VARIABLE v_one_hot : BOOLEAN := FALSE;
710 
    VARIABLE v_zeros   : STD_LOGIC_VECTOR(slv'RANGE) := (OTHERS=>'0');
711 
  BEGIN
712 
    FOR i IN slv'RANGE LOOP
713 
      IF slv(i) = '1' THEN
714 
        IF NOT(v_one_hot) THEN
715 
          -- No hot bits found so far
716 
          v_one_hot := TRUE;
717 
        ELSE
718 
          -- This is the second hot bit found; return zeros.
719 
          RETURN v_zeros;
720 
        END IF;
721 
      END IF;
722 
    END LOOP;
723 
    -- No or a single hot bit found in slv; return slv.
724 
    RETURN slv;
725 
  END;
726 
 
727 
  FUNCTION andv(slv : STD_LOGIC_VECTOR) RETURN STD_LOGIC IS
728 
  BEGIN
729 
    RETURN vector_tree(slv, "AND");
730 
  END;
731 
 
732 
  FUNCTION orv(slv : STD_LOGIC_VECTOR) RETURN STD_LOGIC IS
733 
  BEGIN
734 
    RETURN vector_tree(slv, "OR");
735 
  END;
736 
 
737 
  FUNCTION xorv(slv : STD_LOGIC_VECTOR) RETURN STD_LOGIC IS
738 
  BEGIN
739 
    RETURN vector_tree(slv, "XOR");
740 
  END;
741 
 
742 
  FUNCTION matrix_and(mat : t_sl_matrix; wi, wj : NATURAL) RETURN STD_LOGIC IS
743 
    VARIABLE v_mat    : t_sl_matrix(0 TO wi-1, 0 TO wj-1) := mat;  -- map to fixed range
744 
    VARIABLE v_result : STD_LOGIC := '1';
745 
  BEGIN
746 
    FOR I IN 0 TO wi-1 LOOP
747 
      FOR J IN 0 TO wj-1 LOOP
748 
        v_result := v_result AND v_mat(I,J);
749 
      END LOOP;
750 
    END LOOP;
751 
    RETURN v_result;
752 
  END;
753 
 
754 
  FUNCTION matrix_or(mat : t_sl_matrix; wi, wj : NATURAL) RETURN STD_LOGIC IS
755 
    VARIABLE v_mat    : t_sl_matrix(0 TO wi-1, 0 TO wj-1) := mat;  -- map to fixed range
756 
    VARIABLE v_result : STD_LOGIC := '0';
757 
  BEGIN
758 
    FOR I IN 0 TO wi-1 LOOP
759 
      FOR J IN 0 TO wj-1 LOOP
760 
        v_result := v_result OR v_mat(I,J);
761 
      END LOOP;
762 
    END LOOP;
763 
    RETURN v_result;
764 
  END;
765 
 
766 
  FUNCTION smallest(n, m : INTEGER) RETURN INTEGER IS
767 
  BEGIN
768 
    IF n < m THEN
769 
      RETURN n;
770 
    ELSE
771 
      RETURN m;
772 
    END IF;
773 
  END;
774 
 
775 
  FUNCTION smallest(n, m, l : INTEGER) RETURN INTEGER IS
776 
    VARIABLE v : NATURAL;
777 
  BEGIN
778 
                  v := n;
779 
    IF v > m THEN v := m; END IF;
780 
    IF v > l THEN v := l; END IF;
781 
    RETURN v;
782 
  END;
783 
 
784 
  FUNCTION smallest(n : t_natural_arr) RETURN NATURAL IS
785 
    VARIABLE m : NATURAL := 0;
786 
  BEGIN
787 
    FOR I IN n'RANGE LOOP
788 
      IF n(I) < m THEN
789 
        m := n(I);
790 
      END IF;
791 
    END LOOP;
792 
    RETURN m;
793 
  END;
794 
 
795 
  FUNCTION largest(n, m : INTEGER) RETURN INTEGER IS
796 
  BEGIN
797 
    IF n > m THEN
798 
      RETURN n;
799 
    ELSE
800 
      RETURN m;
801 
    END IF;
802 
  END;
803 
 
804 
  FUNCTION largest(n : t_natural_arr) RETURN NATURAL IS
805 
    VARIABLE m : NATURAL := 0;
806 
  BEGIN
807 
    FOR I IN n'RANGE LOOP
808 
      IF n(I) > m THEN
809 
        m := n(I);
810 
      END IF;
811 
    END LOOP;
812 
    RETURN m;
813 
  END;
814 
 
815 
  FUNCTION func_sum(n : t_natural_arr) RETURN NATURAL IS
816 
    VARIABLE vS : NATURAL;
817 
  BEGIN
818 
    vS := 0;
819 
    FOR I IN n'RANGE LOOP
820 
      vS := vS + n(I);
821 
    END LOOP;
822 
    RETURN vS;
823 
  END;
824 
 
825 
  FUNCTION func_sum(n : t_nat_natural_arr) RETURN NATURAL IS
826 
    VARIABLE vN : t_natural_arr(n'LENGTH-1 DOWNTO 0);
827 
  BEGIN
828 
    vN := to_natural_arr(n);
829 
    RETURN func_sum(vN);
830 
  END;
831 
 
832 
  FUNCTION func_product(n : t_natural_arr) RETURN NATURAL IS
833 
    VARIABLE vP : NATURAL;
834 
  BEGIN
835 
    vP := 1;
836 
    FOR I IN n'RANGE LOOP
837 
      vP := vP * n(I);
838 
    END LOOP;
839 
    RETURN vP;
840 
  END;
841 
 
842 
  FUNCTION func_product(n : t_nat_natural_arr) RETURN NATURAL IS
843 
    VARIABLE vN : t_natural_arr(n'LENGTH-1 DOWNTO 0);
844 
  BEGIN
845 
    vN := to_natural_arr(n);
846 
    RETURN func_product(vN);
847 
  END;
848 
 
849 
  FUNCTION "+" (L, R: t_natural_arr) RETURN t_natural_arr IS
850 
    CONSTANT w  : NATURAL := L'LENGTH;
851 
    VARIABLE vL : t_natural_arr(w-1 DOWNTO 0);
852 
    VARIABLE vR : t_natural_arr(w-1 DOWNTO 0);
853 
    VARIABLE vP : t_natural_arr(w-1 DOWNTO 0);
854 
  BEGIN
855 
    vL := L;
856 
    vR := R;
857 
    FOR I IN vL'RANGE LOOP
858 
      vP(I) := vL(I) + vR(I);
859 
    END LOOP;
860 
    RETURN vP;
861 
  END;
862 
 
863 
  FUNCTION "+" (L: t_natural_arr; R : INTEGER) RETURN t_natural_arr IS
864 
    CONSTANT w  : NATURAL := L'LENGTH;
865 
    VARIABLE vL : t_natural_arr(w-1 DOWNTO 0);
866 
    VARIABLE vP : t_natural_arr(w-1 DOWNTO 0);
867 
  BEGIN
868 
    vL := L;
869 
    FOR I IN vL'RANGE LOOP
870 
      vP(I) := vL(I) + R;
871 
    END LOOP;
872 
    RETURN vP;
873 
  END;
874 
 
875 
  FUNCTION "+" (L: INTEGER; R : t_natural_arr) RETURN t_natural_arr IS
876 
  BEGIN
877 
    RETURN R + L;
878 
  END;
879 
 
880 
  FUNCTION "-" (L, R: t_natural_arr) RETURN t_natural_arr IS
881 
    CONSTANT w  : NATURAL := L'LENGTH;
882 
    VARIABLE vL : t_natural_arr(w-1 DOWNTO 0);
883 
    VARIABLE vR : t_natural_arr(w-1 DOWNTO 0);
884 
    VARIABLE vP : t_natural_arr(w-1 DOWNTO 0);
885 
  BEGIN
886 
    vL := L;
887 
    vR := R;
888 
    FOR I IN vL'RANGE LOOP
889 
      vP(I) := vL(I) - vR(I);
890 
    END LOOP;
891 
    RETURN vP;
892 
  END;
893 
 
894 
  FUNCTION "-" (L, R: t_natural_arr) RETURN t_integer_arr IS
895 
    CONSTANT w  : NATURAL := L'LENGTH;
896 
    VARIABLE vL : t_natural_arr(w-1 DOWNTO 0);
897 
    VARIABLE vR : t_natural_arr(w-1 DOWNTO 0);
898 
    VARIABLE vP : t_integer_arr(w-1 DOWNTO 0);
899 
  BEGIN
900 
    vL := L;
901 
    vR := R;
902 
    FOR I IN vL'RANGE LOOP
903 
      vP(I) := vL(I) - vR(I);
904 
    END LOOP;
905 
    RETURN vP;
906 
  END;
907 
 
908 
  FUNCTION "-" (L: t_natural_arr; R : INTEGER) RETURN t_natural_arr IS
909 
    CONSTANT w  : NATURAL := L'LENGTH;
910 
    VARIABLE vL : t_natural_arr(w-1 DOWNTO 0);
911 
    VARIABLE vP : t_natural_arr(w-1 DOWNTO 0);
912 
  BEGIN
913 
    vL := L;
914 
    FOR I IN vL'RANGE LOOP
915 
      vP(I) := vL(I) - R;
916 
    END LOOP;
917 
    RETURN vP;
918 
  END;
919 
 
920 
  FUNCTION "-" (L: INTEGER; R : t_natural_arr) RETURN t_natural_arr IS
921 
    CONSTANT w  : NATURAL := R'LENGTH;
922 
    VARIABLE vR : t_natural_arr(w-1 DOWNTO 0);
923 
    VARIABLE vP : t_natural_arr(w-1 DOWNTO 0);
924 
  BEGIN
925 
    vR := R;
926 
    FOR I IN vR'RANGE LOOP
927 
      vP(I) := L - vR(I);
928 
    END LOOP;
929 
    RETURN vP;
930 
  END;
931 
 
932 
  FUNCTION "*" (L, R: t_natural_arr) RETURN t_natural_arr IS
933 
    CONSTANT w  : NATURAL := L'LENGTH;
934 
    VARIABLE vL : t_natural_arr(w-1 DOWNTO 0);
935 
    VARIABLE vR : t_natural_arr(w-1 DOWNTO 0);
936 
    VARIABLE vP : t_natural_arr(w-1 DOWNTO 0);
937 
  BEGIN
938 
    vL := L;
939 
    vR := R;
940 
    FOR I IN vL'RANGE LOOP
941 
      vP(I) := vL(I) * vR(I);
942 
    END LOOP;
943 
    RETURN vP;
944 
  END;
945 
 
946 
  FUNCTION "*" (L: t_natural_arr; R : NATURAL) RETURN t_natural_arr IS
947 
    CONSTANT w  : NATURAL := L'LENGTH;
948 
    VARIABLE vL : t_natural_arr(w-1 DOWNTO 0);
949 
    VARIABLE vP : t_natural_arr(w-1 DOWNTO 0);
950 
  BEGIN
951 
    vL := L;
952 
    FOR I IN vL'RANGE LOOP
953 
      vP(I) := vL(I) * R;
954 
    END LOOP;
955 
    RETURN vP;
956 
  END;
957 
 
958 
  FUNCTION "*" (L: NATURAL; R : t_natural_arr) RETURN t_natural_arr IS
959 
  BEGIN
960 
    RETURN R * L;
961 
  END;
962 
 
963 
  FUNCTION "/" (L, R: t_natural_arr) RETURN t_natural_arr IS
964 
    CONSTANT w  : NATURAL := L'LENGTH;
965 
    VARIABLE vL : t_natural_arr(w-1 DOWNTO 0);
966 
    VARIABLE vR : t_natural_arr(w-1 DOWNTO 0);
967 
    VARIABLE vP : t_natural_arr(w-1 DOWNTO 0);
968 
  BEGIN
969 
    vL := L;
970 
    vR := R;
971 
    FOR I IN vL'RANGE LOOP
972 
      vP(I) := vL(I) / vR(I);
973 
    END LOOP;
974 
    RETURN vP;
975 
  END;
976 
 
977 
  FUNCTION "/" (L: t_natural_arr; R : POSITIVE) RETURN t_natural_arr IS
978 
    CONSTANT w  : NATURAL := L'LENGTH;
979 
    VARIABLE vL : t_natural_arr(w-1 DOWNTO 0);
980 
    VARIABLE vP : t_natural_arr(w-1 DOWNTO 0);
981 
  BEGIN
982 
    vL := L;
983 
    FOR I IN vL'RANGE LOOP
984 
      vP(I) := vL(I) / R;
985 
    END LOOP;
986 
    RETURN vP;
987 
  END;
988 
 
989 
  FUNCTION "/" (L: NATURAL; R : t_natural_arr) RETURN t_natural_arr IS
990 
    CONSTANT w  : NATURAL := R'LENGTH;
991 
    VARIABLE vR : t_natural_arr(w-1 DOWNTO 0);
992 
    VARIABLE vP : t_natural_arr(w-1 DOWNTO 0);
993 
  BEGIN
994 
    vR := R;
995 
    FOR I IN vR'RANGE LOOP
996 
      vP(I) := L / vR(I);
997 
    END LOOP;
998 
    RETURN vP;
999 
  END;
1000 
 
1001 
  FUNCTION is_true(a : STD_LOGIC) RETURN BOOLEAN   IS BEGIN IF a='1'  THEN RETURN TRUE; ELSE RETURN FALSE; END IF; END;
1002 
  FUNCTION is_true(a : STD_LOGIC) RETURN NATURAL   IS BEGIN IF a='1'  THEN RETURN 1;    ELSE RETURN 0;     END IF; END;
1003 
  FUNCTION is_true(a : BOOLEAN)   RETURN STD_LOGIC IS BEGIN IF a=TRUE THEN RETURN '1';  ELSE RETURN '0';   END IF; END;
1004 
  FUNCTION is_true(a : BOOLEAN)   RETURN NATURAL   IS BEGIN IF a=TRUE THEN RETURN 1;    ELSE RETURN 0;     END IF; END;
1005 
  FUNCTION is_true(a : INTEGER)   RETURN BOOLEAN   IS BEGIN IF a/=0   THEN RETURN TRUE; ELSE RETURN FALSE; END IF; END;
1006 
  FUNCTION is_true(a : INTEGER)   RETURN STD_LOGIC IS BEGIN IF a/=0   THEN RETURN '1';  ELSE RETURN '0';   END IF; END;
1007 
 
1008 
  FUNCTION sel_a_b(sel, a, b : INTEGER) RETURN INTEGER IS
1009 
  BEGIN
1010 
    IF sel /= 0 THEN
1011 
      RETURN a;
1012 
    ELSE
1013 
      RETURN b;
1014 
    END IF;
1015 
  END;
1016 
 
1017 
  FUNCTION sel_a_b(sel, a, b : BOOLEAN) RETURN BOOLEAN IS
1018 
  BEGIN
1019 
    IF sel = TRUE THEN
1020 
      RETURN a;
1021 
    ELSE
1022 
      RETURN b;
1023 
    END IF;
1024 
  END;
1025 
 
1026 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : INTEGER) RETURN INTEGER IS
1027 
  BEGIN
1028 
    IF sel = TRUE THEN
1029 
      RETURN a;
1030 
    ELSE
1031 
      RETURN b;
1032 
    END IF;
1033 
  END;
1034 
 
1035 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : REAL) RETURN REAL IS
1036 
  BEGIN
1037 
    IF sel = TRUE THEN
1038 
      RETURN a;
1039 
    ELSE
1040 
      RETURN b;
1041 
    END IF;
1042 
  END;
1043 
 
1044 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : STD_LOGIC) RETURN STD_LOGIC IS
1045 
  BEGIN
1046 
    IF sel = TRUE THEN
1047 
      RETURN a;
1048 
    ELSE
1049 
      RETURN b;
1050 
    END IF;
1051 
  END;
1052 
 
1053 
  FUNCTION sel_a_b(sel : INTEGER; a, b : STD_LOGIC) RETURN STD_LOGIC IS
1054 
  BEGIN
1055 
    IF sel /= 0 THEN
1056 
      RETURN a;
1057 
    ELSE
1058 
      RETURN b;
1059 
    END IF;
1060 
  END;
1061 
 
1062 
  FUNCTION sel_a_b(sel : INTEGER; a, b : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
1063 
  BEGIN
1064 
    IF sel /= 0 THEN
1065 
      RETURN a;
1066 
    ELSE
1067 
      RETURN b;
1068 
    END IF;
1069 
  END;
1070 
 
1071 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
1072 
  BEGIN
1073 
    IF sel = TRUE THEN
1074 
      RETURN a;
1075 
    ELSE
1076 
      RETURN b;
1077 
    END IF;
1078 
  END;
1079 
 
1080 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : SIGNED) RETURN SIGNED IS
1081 
  BEGIN
1082 
    IF sel = TRUE THEN
1083 
      RETURN a;
1084 
    ELSE
1085 
      RETURN b;
1086 
    END IF;
1087 
  END;
1088 
 
1089 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : UNSIGNED) RETURN UNSIGNED IS
1090 
  BEGIN
1091 
    IF sel = TRUE THEN
1092 
      RETURN a;
1093 
    ELSE
1094 
      RETURN b;
1095 
    END IF;
1096 
  END;
1097 
 
1098 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : t_integer_arr) RETURN t_integer_arr IS
1099 
  BEGIN
1100 
    IF sel = TRUE THEN
1101 
      RETURN a;
1102 
    ELSE
1103 
      RETURN b;
1104 
    END IF;
1105 
  END;
1106 
 
1107 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : t_natural_arr) RETURN t_natural_arr IS
1108 
  BEGIN
1109 
    IF sel = TRUE THEN
1110 
      RETURN a;
1111 
    ELSE
1112 
      RETURN b;
1113 
    END IF;
1114 
  END;
1115 
 
1116 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : t_nat_integer_arr) RETURN t_nat_integer_arr IS
1117 
  BEGIN
1118 
    IF sel = TRUE THEN
1119 
      RETURN a;
1120 
    ELSE
1121 
      RETURN b;
1122 
    END IF;
1123 
  END;
1124 
 
1125 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : t_nat_natural_arr) RETURN t_nat_natural_arr IS
1126 
  BEGIN
1127 
    IF sel = TRUE THEN
1128 
      RETURN a;
1129 
    ELSE
1130 
      RETURN b;
1131 
    END IF;
1132 
  END;
1133 
 
1134 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : STRING) RETURN STRING IS
1135 
  BEGIN
1136 
    IF sel = TRUE THEN
1137 
      RETURN a;
1138 
    ELSE
1139 
      RETURN b;
1140 
    END IF;
1141 
  END;
1142 
 
1143 
  FUNCTION sel_a_b(sel : INTEGER; a, b : STRING) RETURN STRING IS
1144 
  BEGIN
1145 
    IF sel /= 0 THEN
1146 
      RETURN a;
1147 
    ELSE
1148 
      RETURN b;
1149 
    END IF;
1150 
  END;
1151 
 
1152 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : TIME) RETURN TIME IS
1153 
  BEGIN
1154 
    IF sel = TRUE THEN
1155 
      RETURN a;
1156 
    ELSE
1157 
      RETURN b;
1158 
    END IF;
1159 
  END;
1160 
 
1161 
  FUNCTION sel_a_b(sel : BOOLEAN; a, b : SEVERITY_LEVEL) RETURN SEVERITY_LEVEL IS
1162 
  BEGIN
1163 
    IF sel = TRUE THEN
1164 
      RETURN a;
1165 
    ELSE
1166 
      RETURN b;
1167 
    END IF;
1168 
  END;
1169 
 
1170 
  -- sel_n : boolean
1171 
  FUNCTION sel_n(sel : NATURAL; a, b, c : BOOLEAN) RETURN BOOLEAN IS
1172 
    CONSTANT c_arr : t_nat_boolean_arr := (a, b, c);
1173 
  BEGIN
1174 
    RETURN c_arr(sel);
1175 
  END;
1176 
 
1177 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d : BOOLEAN) RETURN BOOLEAN IS
1178 
    CONSTANT c_arr : t_nat_boolean_arr := (a, b, c, d);
1179 
  BEGIN
1180 
    RETURN c_arr(sel);
1181 
  END;
1182 
 
1183 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e : BOOLEAN) RETURN BOOLEAN IS
1184 
    CONSTANT c_arr : t_nat_boolean_arr := (a, b, c, d, e);
1185 
  BEGIN
1186 
    RETURN c_arr(sel);
1187 
  END;
1188 
 
1189 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f : BOOLEAN) RETURN BOOLEAN IS
1190 
    CONSTANT c_arr : t_nat_boolean_arr := (a, b, c, d, e, f);
1191 
  BEGIN
1192 
    RETURN c_arr(sel);
1193 
  END;
1194 
 
1195 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g : BOOLEAN) RETURN BOOLEAN IS
1196 
    CONSTANT c_arr : t_nat_boolean_arr := (a, b, c, d, e, f, g);
1197 
  BEGIN
1198 
    RETURN c_arr(sel);
1199 
  END;
1200 
 
1201 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h : BOOLEAN) RETURN BOOLEAN IS
1202 
    CONSTANT c_arr : t_nat_boolean_arr := (a, b, c, d, e, f, g, h);
1203 
  BEGIN
1204 
    RETURN c_arr(sel);
1205 
  END;
1206 
 
1207 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h, i : BOOLEAN) RETURN BOOLEAN IS
1208 
    CONSTANT c_arr : t_nat_boolean_arr := (a, b, c, d, e, f, g, h, i);
1209 
  BEGIN
1210 
    RETURN c_arr(sel);
1211 
  END;
1212 
 
1213 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h, i, j : BOOLEAN) RETURN BOOLEAN IS
1214 
    CONSTANT c_arr : t_nat_boolean_arr := (a, b, c, d, e, f, g, h, i, j);
1215 
  BEGIN
1216 
    RETURN c_arr(sel);
1217 
  END;
1218 
 
1219 
  -- sel_n : integer
1220 
  FUNCTION sel_n(sel : NATURAL; a, b, c : INTEGER) RETURN INTEGER IS
1221 
    CONSTANT c_arr : t_nat_integer_arr := (a, b, c);
1222 
  BEGIN
1223 
    RETURN c_arr(sel);
1224 
  END;
1225 
 
1226 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d : INTEGER) RETURN INTEGER IS
1227 
    CONSTANT c_arr : t_nat_integer_arr := (a, b, c, d);
1228 
  BEGIN
1229 
    RETURN c_arr(sel);
1230 
  END;
1231 
 
1232 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e : INTEGER) RETURN INTEGER IS
1233 
    CONSTANT c_arr : t_nat_integer_arr := (a, b, c, d, e);
1234 
  BEGIN
1235 
    RETURN c_arr(sel);
1236 
  END;
1237 
 
1238 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f : INTEGER) RETURN INTEGER IS
1239 
    CONSTANT c_arr : t_nat_integer_arr := (a, b, c, d, e, f);
1240 
  BEGIN
1241 
    RETURN c_arr(sel);
1242 
  END;
1243 
 
1244 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g : INTEGER) RETURN INTEGER IS
1245 
    CONSTANT c_arr : t_nat_integer_arr := (a, b, c, d, e, f, g);
1246 
  BEGIN
1247 
    RETURN c_arr(sel);
1248 
  END;
1249 
 
1250 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h : INTEGER) RETURN INTEGER IS
1251 
    CONSTANT c_arr : t_nat_integer_arr := (a, b, c, d, e, f, g, h);
1252 
  BEGIN
1253 
    RETURN c_arr(sel);
1254 
  END;
1255 
 
1256 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h, i : INTEGER) RETURN INTEGER IS
1257 
    CONSTANT c_arr : t_nat_integer_arr := (a, b, c, d, e, f, g, h, i);
1258 
  BEGIN
1259 
    RETURN c_arr(sel);
1260 
  END;
1261 
 
1262 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h, i, j : INTEGER) RETURN INTEGER IS
1263 
    CONSTANT c_arr : t_nat_integer_arr := (a, b, c, d, e, f, g, h, i, j);
1264 
  BEGIN
1265 
    RETURN c_arr(sel);
1266 
  END;
1267 
 
1268 
  -- sel_n : string
1269 
  FUNCTION sel_n(sel : NATURAL; a, b                         : STRING) RETURN STRING IS BEGIN IF sel=0 THEN RETURN            a                         ; ELSE RETURN b; END IF; END;
1270 
  FUNCTION sel_n(sel : NATURAL; a, b, c                      : STRING) RETURN STRING IS BEGIN IF sel<2 THEN RETURN sel_n(sel, a, b                     ); ELSE RETURN c; END IF; END;
1271 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d                   : STRING) RETURN STRING IS BEGIN IF sel<3 THEN RETURN sel_n(sel, a, b, c                  ); ELSE RETURN d; END IF; END;
1272 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e                : STRING) RETURN STRING IS BEGIN IF sel<4 THEN RETURN sel_n(sel, a, b, c, d               ); ELSE RETURN e; END IF; END;
1273 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f             : STRING) RETURN STRING IS BEGIN IF sel<5 THEN RETURN sel_n(sel, a, b, c, d, e            ); ELSE RETURN f; END IF; END;
1274 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g          : STRING) RETURN STRING IS BEGIN IF sel<6 THEN RETURN sel_n(sel, a, b, c, d, e, f         ); ELSE RETURN g; END IF; END;
1275 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h       : STRING) RETURN STRING IS BEGIN IF sel<7 THEN RETURN sel_n(sel, a, b, c, d, e, f, g      ); ELSE RETURN h; END IF; END;
1276 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h, i    : STRING) RETURN STRING IS BEGIN IF sel<8 THEN RETURN sel_n(sel, a, b, c, d, e, f, g, h   ); ELSE RETURN i; END IF; END;
1277 
  FUNCTION sel_n(sel : NATURAL; a, b, c, d, e, f, g, h, i, j : STRING) RETURN STRING IS BEGIN IF sel<9 THEN RETURN sel_n(sel, a, b, c, d, e, f, g, h, i); ELSE RETURN j; END IF; END;
1278 
 
1279 
  FUNCTION array_init(init : STD_LOGIC; nof : NATURAL) RETURN STD_LOGIC_VECTOR IS
1280 
    VARIABLE v_arr : STD_LOGIC_VECTOR(0 TO nof-1);
1281 
  BEGIN
1282 
    FOR I IN v_arr'RANGE LOOP
1283 
      v_arr(I) := init;
1284 
    END LOOP;
1285 
    RETURN v_arr;
1286 
  END;
1287 
 
1288 
  FUNCTION array_init(init, nof : NATURAL) RETURN t_natural_arr IS
1289 
    VARIABLE v_arr : t_natural_arr(0 TO nof-1);
1290 
  BEGIN
1291 
    FOR I IN v_arr'RANGE LOOP
1292 
      v_arr(I) := init;
1293 
    END LOOP;
1294 
    RETURN v_arr;
1295 
  END;
1296 
 
1297 
  FUNCTION array_init(init, nof : NATURAL) RETURN t_nat_natural_arr IS
1298 
    VARIABLE v_arr : t_nat_natural_arr(0 TO nof-1);
1299 
  BEGIN
1300 
    FOR I IN v_arr'RANGE LOOP
1301 
      v_arr(I) := init;
1302 
    END LOOP;
1303 
    RETURN v_arr;
1304 
  END;
1305 
 
1306 
  FUNCTION array_init(init, nof, incr : NATURAL) RETURN t_natural_arr IS
1307 
    VARIABLE v_arr : t_natural_arr(0 TO nof-1);
1308 
    VARIABLE v_i   : NATURAL;
1309 
  BEGIN
1310 
    v_i := 0;
1311 
    FOR I IN v_arr'RANGE LOOP
1312 
      v_arr(I) := init + v_i * incr;
1313 
      v_i := v_i + 1;
1314 
    END LOOP;
1315 
    RETURN v_arr;
1316 
  END;
1317 
 
1318 
  FUNCTION array_init(init, nof, incr : NATURAL) RETURN t_nat_natural_arr IS
1319 
    VARIABLE v_arr : t_nat_natural_arr(0 TO nof-1);
1320 
    VARIABLE v_i   : NATURAL;
1321 
  BEGIN
1322 
    v_i := 0;
1323 
    FOR I IN v_arr'RANGE LOOP
1324 
      v_arr(I) := init + v_i * incr;
1325 
      v_i := v_i + 1;
1326 
    END LOOP;
1327 
    RETURN v_arr;
1328 
  END;
1329 
 
1330 
  FUNCTION array_init(init, nof, incr : INTEGER) RETURN t_slv_16_arr IS
1331 
    VARIABLE v_arr : t_slv_16_arr(0 TO nof-1);
1332 
    VARIABLE v_i   : NATURAL;
1333 
  BEGIN
1334 
    v_i := 0;
1335 
    FOR I IN v_arr'RANGE LOOP
1336 
      v_arr(I) := TO_SVEC(init + v_i * incr, 16);
1337 
      v_i := v_i + 1;
1338 
    END LOOP;
1339 
    RETURN v_arr;
1340 
  END;
1341 
 
1342 
  FUNCTION array_init(init, nof, incr : INTEGER) RETURN t_slv_32_arr IS
1343 
    VARIABLE v_arr : t_slv_32_arr(0 TO nof-1);
1344 
    VARIABLE v_i   : NATURAL;
1345 
  BEGIN
1346 
    v_i := 0;
1347 
    FOR I IN v_arr'RANGE LOOP
1348 
      v_arr(I) := TO_SVEC(init + v_i * incr, 32);
1349 
      v_i := v_i + 1;
1350 
    END LOOP;
1351 
    RETURN v_arr;
1352 
  END;
1353 
 
1354 
  FUNCTION array_init(init, nof, width : NATURAL) RETURN STD_LOGIC_VECTOR IS
1355 
    VARIABLE v_arr : STD_LOGIC_VECTOR(nof*width-1 DOWNTO 0);
1356 
  BEGIN
1357 
    FOR I IN 0 TO nof-1 LOOP
1358 
      v_arr(width*(I+1)-1 DOWNTO width*I) := TO_UVEC(init, width);
1359 
    END LOOP;
1360 
    RETURN v_arr;
1361 
  END;
1362 
 
1363 
  FUNCTION array_init(init, nof, width, incr : NATURAL) RETURN STD_LOGIC_VECTOR IS
1364 
    VARIABLE v_arr : STD_LOGIC_VECTOR(nof*width-1 DOWNTO 0);
1365 
    VARIABLE v_i   : NATURAL;
1366 
  BEGIN
1367 
    v_i := 0;
1368 
    FOR I IN 0 TO nof-1 LOOP
1369 
      v_arr(width*(I+1)-1 DOWNTO width*I) := TO_UVEC(init + v_i * incr, width);
1370 
      v_i := v_i + 1;
1371 
    END LOOP;
1372 
    RETURN v_arr;
1373 
  END;
1374 
 
1375 
  FUNCTION array_sinit(init :INTEGER; nof, width : NATURAL) RETURN STD_LOGIC_VECTOR IS
1376 
    VARIABLE v_arr : STD_LOGIC_VECTOR(nof*width-1 DOWNTO 0);
1377 
  BEGIN
1378 
    FOR I IN 0 TO nof-1 LOOP
1379 
      v_arr(width*(I+1)-1 DOWNTO width*I) := TO_SVEC(init, width);
1380 
    END LOOP;
1381 
    RETURN v_arr;
1382 
  END;
1383 
 
1384 
  FUNCTION init_slv_64_matrix(nof_a, nof_b, k : INTEGER) RETURN t_slv_64_matrix IS
1385 
    VARIABLE v_mat : t_slv_64_matrix(nof_a-1 DOWNTO 0, nof_b-1 DOWNTO 0);
1386 
  BEGIN
1387 
    FOR I IN 0 TO nof_a-1 LOOP
1388 
      FOR J IN 0 TO nof_b-1 LOOP
1389 
        v_mat(I,J) := TO_SVEC(k, 64);
1390 
      END LOOP;
1391 
    END LOOP;
1392 
    RETURN v_mat;
1393 
  END;
1394 
 
1395 
 
1396 
  -- Support concatenation of up to 7 slv into 1 slv
1397 
  FUNCTION func_slv_concat(use_a, use_b, use_c, use_d, use_e, use_f, use_g : BOOLEAN; a, b, c, d, e, f, g : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
1398 
    CONSTANT c_max_w : NATURAL := a'LENGTH + b'LENGTH + c'LENGTH + d'LENGTH + e'LENGTH + f'LENGTH + g'LENGTH;
1399 
    VARIABLE v_res   : STD_LOGIC_VECTOR(c_max_w-1 DOWNTO 0) := (OTHERS=>'0');
1400 
    VARIABLE v_len   : NATURAL := 0;
1401 
  BEGIN
1402 
    IF use_a = TRUE THEN v_res(a'LENGTH-1 + v_len DOWNTO v_len) := a; v_len := v_len + a'LENGTH; END IF;
1403 
    IF use_b = TRUE THEN v_res(b'LENGTH-1 + v_len DOWNTO v_len) := b; v_len := v_len + b'LENGTH; END IF;
1404 
    IF use_c = TRUE THEN v_res(c'LENGTH-1 + v_len DOWNTO v_len) := c; v_len := v_len + c'LENGTH; END IF;
1405 
    IF use_d = TRUE THEN v_res(d'LENGTH-1 + v_len DOWNTO v_len) := d; v_len := v_len + d'LENGTH; END IF;
1406 
    IF use_e = TRUE THEN v_res(e'LENGTH-1 + v_len DOWNTO v_len) := e; v_len := v_len + e'LENGTH; END IF;
1407 
    IF use_f = TRUE THEN v_res(f'LENGTH-1 + v_len DOWNTO v_len) := f; v_len := v_len + f'LENGTH; END IF;
1408 
    IF use_g = TRUE THEN v_res(g'LENGTH-1 + v_len DOWNTO v_len) := g; v_len := v_len + g'LENGTH; END IF;
1409 
    RETURN v_res(v_len-1 DOWNTO 0);
1410 
  END func_slv_concat;
1411 
 
1412 
  FUNCTION func_slv_concat(use_a, use_b, use_c, use_d, use_e, use_f : BOOLEAN; a, b, c, d, e, f : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
1413 
  BEGIN
1414 
    RETURN func_slv_concat(use_a, use_b, use_c, use_d, use_e, use_f, FALSE, a, b, c, d, e, f, "0");
1415 
  END func_slv_concat;
1416 
 
1417 
  FUNCTION func_slv_concat(use_a, use_b, use_c, use_d, use_e : BOOLEAN; a, b, c, d, e : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
1418 
  BEGIN
1419 
    RETURN func_slv_concat(use_a, use_b, use_c, use_d, use_e, FALSE, FALSE, a, b, c, d, e, "0", "0");
1420 
  END func_slv_concat;
1421 
 
1422 
  FUNCTION func_slv_concat(use_a, use_b, use_c, use_d : BOOLEAN; a, b, c, d : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
1423 
  BEGIN
1424 
    RETURN func_slv_concat(use_a, use_b, use_c, use_d, FALSE, FALSE, FALSE, a, b, c, d, "0", "0", "0");
1425 
  END func_slv_concat;
1426 
 
1427 
  FUNCTION func_slv_concat(use_a, use_b, use_c : BOOLEAN; a, b, c : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
1428 
  BEGIN
1429 
    RETURN func_slv_concat(use_a, use_b, use_c, FALSE, FALSE, FALSE, FALSE, a, b, c, "0", "0", "0", "0");
1430 
  END func_slv_concat;
1431 
 
1432 
  FUNCTION func_slv_concat(use_a, use_b : BOOLEAN; a, b : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
1433 
  BEGIN
1434 
    RETURN func_slv_concat(use_a, use_b, FALSE, FALSE, FALSE, FALSE, FALSE, a, b, "0", "0", "0", "0", "0");
1435 
  END func_slv_concat;
1436 
 
1437 
  FUNCTION func_slv_concat_w(use_a, use_b, use_c, use_d, use_e, use_f, use_g : BOOLEAN; a_w, b_w, c_w, d_w, e_w, f_w, g_w : NATURAL) RETURN NATURAL IS
1438 
    VARIABLE v_len : NATURAL := 0;
1439 
  BEGIN
1440 
    IF use_a = TRUE THEN v_len := v_len + a_w; END IF;
1441 
    IF use_b = TRUE THEN v_len := v_len + b_w; END IF;
1442 
    IF use_c = TRUE THEN v_len := v_len + c_w; END IF;
1443 
    IF use_d = TRUE THEN v_len := v_len + d_w; END IF;
1444 
    IF use_e = TRUE THEN v_len := v_len + e_w; END IF;
1445 
    IF use_f = TRUE THEN v_len := v_len + f_w; END IF;
1446 
    IF use_g = TRUE THEN v_len := v_len + g_w; END IF;
1447 
    RETURN v_len;
1448 
  END func_slv_concat_w;
1449 
 
1450 
  FUNCTION func_slv_concat_w(use_a, use_b, use_c, use_d, use_e, use_f : BOOLEAN; a_w, b_w, c_w, d_w, e_w, f_w : NATURAL) RETURN NATURAL IS
1451 
  BEGIN
1452 
    RETURN func_slv_concat_w(use_a, use_b, use_c, use_d, use_e, use_f, FALSE, a_w, b_w, c_w, d_w, e_w, f_w, 0);
1453 
  END func_slv_concat_w;
1454 
 
1455 
  FUNCTION func_slv_concat_w(use_a, use_b, use_c, use_d, use_e : BOOLEAN; a_w, b_w, c_w, d_w, e_w : NATURAL) RETURN NATURAL IS
1456 
  BEGIN
1457 
    RETURN func_slv_concat_w(use_a, use_b, use_c, use_d, use_e, FALSE, FALSE, a_w, b_w, c_w, d_w, e_w, 0, 0);
1458 
  END func_slv_concat_w;
1459 
 
1460 
  FUNCTION func_slv_concat_w(use_a, use_b, use_c, use_d : BOOLEAN; a_w, b_w, c_w, d_w : NATURAL) RETURN NATURAL IS
1461 
  BEGIN
1462 
    RETURN func_slv_concat_w(use_a, use_b, use_c, use_d, FALSE, FALSE, FALSE, a_w, b_w, c_w, d_w, 0, 0, 0);
1463 
  END func_slv_concat_w;
1464 
 
1465 
  FUNCTION func_slv_concat_w(use_a, use_b, use_c : BOOLEAN; a_w, b_w, c_w : NATURAL) RETURN NATURAL IS
1466 
  BEGIN
1467 
    RETURN func_slv_concat_w(use_a, use_b, use_c, FALSE, FALSE, FALSE, FALSE, a_w, b_w, c_w, 0, 0, 0, 0);
1468 
  END func_slv_concat_w;
1469 
 
1470 
  FUNCTION func_slv_concat_w(use_a, use_b : BOOLEAN; a_w, b_w : NATURAL) RETURN NATURAL IS
1471 
  BEGIN
1472 
    RETURN func_slv_concat_w(use_a, use_b, FALSE, FALSE, FALSE, FALSE, FALSE, a_w, b_w, 0, 0, 0, 0, 0);
1473 
  END func_slv_concat_w;
1474 
 
1475 
  -- extract slv
1476 
  FUNCTION func_slv_extract(use_a, use_b, use_c, use_d, use_e, use_f, use_g : BOOLEAN; a_w, b_w, c_w, d_w, e_w, f_w, g_w : NATURAL; vec : STD_LOGIC_VECTOR; sel : NATURAL) RETURN STD_LOGIC_VECTOR IS
1477 
    VARIABLE v_w  : NATURAL := 0;
1478 
    VARIABLE v_lo : NATURAL := 0;
1479 
  BEGIN
1480 
    -- if the selected slv is not used in vec, then return dummy, else return the selected slv from vec
1481 
    CASE sel IS
1482 
      WHEN 0 =>
1483 
        IF use_a = TRUE THEN v_w := a_w; ELSE RETURN c_slv0(a_w-1 DOWNTO 0); END IF;
1484 
      WHEN 1 =>
1485 
        IF use_b = TRUE THEN v_w := b_w; ELSE RETURN c_slv0(b_w-1 DOWNTO 0); END IF;
1486 
        IF use_a = TRUE THEN v_lo := v_lo + a_w; END IF;
1487 
      WHEN 2 =>
1488 
        IF use_c = TRUE THEN v_w := c_w; ELSE RETURN c_slv0(c_w-1 DOWNTO 0); END IF;
1489 
        IF use_a = TRUE THEN v_lo := v_lo + a_w; END IF;
1490 
        IF use_b = TRUE THEN v_lo := v_lo + b_w; END IF;
1491 
      WHEN 3 =>
1492 
        IF use_d = TRUE THEN v_w := d_w; ELSE RETURN c_slv0(d_w-1 DOWNTO 0); END IF;
1493 
        IF use_a = TRUE THEN v_lo := v_lo + a_w; END IF;
1494 
        IF use_b = TRUE THEN v_lo := v_lo + b_w; END IF;
1495 
        IF use_c = TRUE THEN v_lo := v_lo + c_w; END IF;
1496 
      WHEN 4 =>
1497 
        IF use_e = TRUE THEN v_w := e_w; ELSE RETURN c_slv0(e_w-1 DOWNTO 0); END IF;
1498 
        IF use_a = TRUE THEN v_lo := v_lo + a_w; END IF;
1499 
        IF use_b = TRUE THEN v_lo := v_lo + b_w; END IF;
1500 
        IF use_c = TRUE THEN v_lo := v_lo + c_w; END IF;
1501 
        IF use_d = TRUE THEN v_lo := v_lo + d_w; END IF;
1502 
      WHEN 5 =>
1503 
        IF use_f = TRUE THEN v_w := f_w; ELSE RETURN c_slv0(f_w-1 DOWNTO 0); END IF;
1504 
        IF use_a = TRUE THEN v_lo := v_lo + a_w; END IF;
1505 
        IF use_b = TRUE THEN v_lo := v_lo + b_w; END IF;
1506 
        IF use_c = TRUE THEN v_lo := v_lo + c_w; END IF;
1507 
        IF use_d = TRUE THEN v_lo := v_lo + d_w; END IF;
1508 
        IF use_e = TRUE THEN v_lo := v_lo + e_w; END IF;
1509 
      WHEN 6 =>
1510 
        IF use_g = TRUE THEN v_w := g_w; ELSE RETURN c_slv0(g_w-1 DOWNTO 0); END IF;
1511 
        IF use_a = TRUE THEN v_lo := v_lo + a_w; END IF;
1512 
        IF use_b = TRUE THEN v_lo := v_lo + b_w; END IF;
1513 
        IF use_c = TRUE THEN v_lo := v_lo + c_w; END IF;
1514 
        IF use_d = TRUE THEN v_lo := v_lo + d_w; END IF;
1515 
        IF use_e = TRUE THEN v_lo := v_lo + e_w; END IF;
1516 
        IF use_f = TRUE THEN v_lo := v_lo + f_w; END IF;
1517 
      WHEN OTHERS => REPORT "Unknown common_pkg func_slv_extract argument" SEVERITY FAILURE;
1518 
    END CASE;
1519 
    RETURN vec(v_w-1 + v_lo DOWNTO v_lo);  -- extracted slv
1520 
  END func_slv_extract;
1521 
 
1522 
  FUNCTION func_slv_extract(use_a, use_b, use_c, use_d, use_e, use_f : BOOLEAN; a_w, b_w, c_w, d_w, e_w, f_w : NATURAL; vec : STD_LOGIC_VECTOR; sel : NATURAL) RETURN STD_LOGIC_VECTOR IS
1523 
  BEGIN
1524 
    RETURN func_slv_extract(use_a, use_b, use_c, use_d, use_e, use_f, FALSE, a_w, b_w, c_w, d_w, e_w, f_w, 0, vec, sel);
1525 
  END func_slv_extract;
1526 
 
1527 
  FUNCTION func_slv_extract(use_a, use_b, use_c, use_d, use_e : BOOLEAN; a_w, b_w, c_w, d_w, e_w : NATURAL; vec : STD_LOGIC_VECTOR; sel : NATURAL) RETURN STD_LOGIC_VECTOR IS
1528 
  BEGIN
1529 
    RETURN func_slv_extract(use_a, use_b, use_c, use_d, use_e, FALSE, FALSE, a_w, b_w, c_w, d_w, e_w, 0, 0, vec, sel);
1530 
  END func_slv_extract;
1531 
 
1532 
  FUNCTION func_slv_extract(use_a, use_b, use_c, use_d : BOOLEAN; a_w, b_w, c_w, d_w : NATURAL; vec : STD_LOGIC_VECTOR; sel : NATURAL) RETURN STD_LOGIC_VECTOR IS
1533 
  BEGIN
1534 
    RETURN func_slv_extract(use_a, use_b, use_c, use_d, FALSE, FALSE, FALSE, a_w, b_w, c_w, d_w, 0, 0, 0, vec, sel);
1535 
  END func_slv_extract;
1536 
 
1537 
  FUNCTION func_slv_extract(use_a, use_b, use_c : BOOLEAN; a_w, b_w, c_w : NATURAL; vec : STD_LOGIC_VECTOR; sel : NATURAL) RETURN STD_LOGIC_VECTOR IS
1538 
  BEGIN
1539 
    RETURN func_slv_extract(use_a, use_b, use_c, FALSE, FALSE, FALSE, FALSE, a_w, b_w, c_w, 0, 0, 0, 0, vec, sel);
1540 
  END func_slv_extract;
1541 
 
1542 
  FUNCTION func_slv_extract(use_a, use_b : BOOLEAN; a_w, b_w : NATURAL; vec : STD_LOGIC_VECTOR; sel : NATURAL) RETURN STD_LOGIC_VECTOR IS
1543 
  BEGIN
1544 
    RETURN func_slv_extract(use_a, use_b, FALSE, FALSE, FALSE, FALSE, FALSE, a_w, b_w, 0, 0, 0, 0, 0, vec, sel);
1545 
  END func_slv_extract;
1546 
 
1547 
 
1548 
  FUNCTION TO_UINT(vec : STD_LOGIC_VECTOR) RETURN NATURAL IS
1549 
  BEGIN
1550 
    RETURN TO_INTEGER(UNSIGNED(vec));
1551 
  END;
1552 
 
1553 
  FUNCTION TO_SINT(vec : STD_LOGIC_VECTOR) RETURN INTEGER IS
1554 
  BEGIN
1555 
    RETURN TO_INTEGER(SIGNED(vec));
1556 
  END;
1557 
 
1558 
  FUNCTION TO_UVEC(dec, w : NATURAL) RETURN STD_LOGIC_VECTOR IS
1559 
  BEGIN
1560 
    RETURN STD_LOGIC_VECTOR(TO_UNSIGNED(dec, w));
1561 
  END;
1562 
 
1563 
  FUNCTION TO_SVEC(dec, w : INTEGER) RETURN STD_LOGIC_VECTOR IS
1564 
  BEGIN
1565 
    RETURN STD_LOGIC_VECTOR(TO_SIGNED(dec, w));
1566 
  END;
1567 
 
1568 
  FUNCTION TO_SVEC_32(dec : INTEGER) RETURN STD_LOGIC_VECTOR IS
1569 
  BEGIN
1570 
    RETURN TO_SVEC(dec, 32);
1571 
  END;
1572 
 
1573 
  FUNCTION RESIZE_NUM(u : UNSIGNED; w : NATURAL) RETURN UNSIGNED IS
1574 
  BEGIN
1575 
    -- left extend with '0' or keep LS part (same as RESIZE for UNSIGNED)
1576 
    RETURN RESIZE(u, w);
1577 
  END;
1578 
 
1579 
  FUNCTION RESIZE_NUM(s : SIGNED; w : NATURAL) RETURN SIGNED IS
1580 
  BEGIN
1581 
    -- extend sign bit or keep LS part
1582 
    IF w>s'LENGTH THEN
1583 
      RETURN RESIZE(s, w);                    -- extend sign bit
1584 
    ELSE
1585 
      RETURN SIGNED(RESIZE(UNSIGNED(s), w));  -- keep LSbits (= vec[w-1:0])
1586 
    END IF;
1587 
  END;
1588 
 
1589 
  FUNCTION RESIZE_UVEC(sl : STD_LOGIC; w : NATURAL) RETURN STD_LOGIC_VECTOR IS
1590 
    VARIABLE v_slv0 : STD_LOGIC_VECTOR(w-1 DOWNTO 1) := (OTHERS=>'0');
1591 
  BEGIN
1592 
    RETURN v_slv0 & sl;
1593 
  END;
1594 
 
1595 
  FUNCTION RESIZE_UVEC(vec : STD_LOGIC_VECTOR; w : NATURAL) RETURN STD_LOGIC_VECTOR IS
1596 
  BEGIN
1597 
    RETURN STD_LOGIC_VECTOR(RESIZE_NUM(UNSIGNED(vec), w));
1598 
  END;
1599 
 
1600 
  FUNCTION RESIZE_SVEC(vec : STD_LOGIC_VECTOR; w : NATURAL) RETURN STD_LOGIC_VECTOR IS
1601 
  BEGIN
1602 
    RETURN STD_LOGIC_VECTOR(RESIZE_NUM(SIGNED(vec), w));
1603 
  END;
1604 
 
1605 
  FUNCTION RESIZE_UINT(u : INTEGER; w : NATURAL) RETURN INTEGER IS
1606 
    VARIABLE v : STD_LOGIC_VECTOR(c_word_w-1 DOWNTO 0);
1607 
  BEGIN
1608 
    v := TO_UVEC(u, c_word_w);
1609 
    RETURN TO_UINT(v(w-1 DOWNTO 0));
1610 
  END;
1611 
 
1612 
  FUNCTION RESIZE_SINT(s : INTEGER; w : NATURAL) RETURN INTEGER IS
1613 
    VARIABLE v : STD_LOGIC_VECTOR(c_word_w-1 DOWNTO 0);
1614 
  BEGIN
1615 
    v := TO_SVEC(s, c_word_w);
1616 
    RETURN TO_SINT(v(w-1 DOWNTO 0));
1617 
  END;
1618 
 
1619 
  FUNCTION RESIZE_UVEC_32(vec : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
1620 
  BEGIN
1621 
    RETURN RESIZE_UVEC(vec, 32);
1622 
  END;
1623 
 
1624 
  FUNCTION RESIZE_SVEC_32(vec : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
1625 
  BEGIN
1626 
    RETURN RESIZE_SVEC(vec, 32);
1627 
  END;
1628 
 
1629 
  FUNCTION INCR_UVEC(vec : STD_LOGIC_VECTOR; dec : INTEGER) RETURN STD_LOGIC_VECTOR IS
1630 
    VARIABLE v_dec : INTEGER;
1631 
  BEGIN
1632 
    IF dec < 0 THEN
1633 
      v_dec := -dec;
1634 
      RETURN STD_LOGIC_VECTOR(UNSIGNED(vec) - v_dec);  -- uses function "-" (L : UNSIGNED, R : NATURAL), there is no function + with R : INTEGER argument
1635 
    ELSE
1636 
      v_dec := dec;
1637 
      RETURN STD_LOGIC_VECTOR(UNSIGNED(vec) + v_dec);  -- uses function "+" (L : UNSIGNED, R : NATURAL)
1638 
    END IF;
1639 
  END;
1640 
 
1641 
  FUNCTION INCR_UVEC(vec : STD_LOGIC_VECTOR; dec : UNSIGNED) RETURN STD_LOGIC_VECTOR IS
1642 
  BEGIN
1643 
    RETURN STD_LOGIC_VECTOR(UNSIGNED(vec) + dec);
1644 
  END;
1645 
 
1646 
  FUNCTION INCR_SVEC(vec : STD_LOGIC_VECTOR; dec : INTEGER) RETURN STD_LOGIC_VECTOR IS
1647 
    VARIABLE v_dec : INTEGER;
1648 
  BEGIN
1649 
    RETURN STD_LOGIC_VECTOR(SIGNED(vec) + v_dec);  -- uses function "+" (L : SIGNED, R : INTEGER)
1650 
  END;
1651 
 
1652 
  FUNCTION INCR_SVEC(vec : STD_LOGIC_VECTOR; dec : SIGNED) RETURN STD_LOGIC_VECTOR IS
1653 
  BEGIN
1654 
    RETURN STD_LOGIC_VECTOR(SIGNED(vec) + dec);
1655 
  END;
1656 
 
1657 
  FUNCTION ADD_SVEC(l_vec : STD_LOGIC_VECTOR; r_vec : STD_LOGIC_VECTOR; res_w : NATURAL) RETURN STD_LOGIC_VECTOR IS
1658 
  BEGIN
1659 
    RETURN STD_LOGIC_VECTOR(RESIZE_NUM(SIGNED(l_vec), res_w) + SIGNED(r_vec));
1660 
  END;
1661 
 
1662 
  FUNCTION SUB_SVEC(l_vec : STD_LOGIC_VECTOR; r_vec : STD_LOGIC_VECTOR; res_w : NATURAL) RETURN STD_LOGIC_VECTOR IS
1663 
  BEGIN
1664 
    RETURN STD_LOGIC_VECTOR(RESIZE_NUM(SIGNED(l_vec), res_w) - SIGNED(r_vec));
1665 
  END;
1666 
 
1667 
  FUNCTION ADD_UVEC(l_vec : STD_LOGIC_VECTOR; r_vec : STD_LOGIC_VECTOR; res_w : NATURAL) RETURN STD_LOGIC_VECTOR IS
1668 
  BEGIN
1669 
    RETURN STD_LOGIC_VECTOR(RESIZE_NUM(UNSIGNED(l_vec), res_w) + UNSIGNED(r_vec));
1670 
  END;
1671 
 
1672 
  FUNCTION SUB_UVEC(l_vec : STD_LOGIC_VECTOR; r_vec : STD_LOGIC_VECTOR; res_w : NATURAL) RETURN STD_LOGIC_VECTOR IS
1673 
  BEGIN
1674 
    RETURN STD_LOGIC_VECTOR(RESIZE_NUM(UNSIGNED(l_vec), res_w) - UNSIGNED(r_vec));
1675 
  END;
1676 
 
1677 
 
1678 
  FUNCTION ADD_SVEC(l_vec : STD_LOGIC_VECTOR; r_vec : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
1679 
  BEGIN
1680 
    RETURN ADD_SVEC(l_vec, r_vec, l_vec'LENGTH);
1681 
  END;
1682 
 
1683 
  FUNCTION SUB_SVEC(l_vec : STD_LOGIC_VECTOR; r_vec : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
1684 
  BEGIN
1685 
    RETURN SUB_SVEC(l_vec, r_vec, l_vec'LENGTH);
1686 
  END;
1687 
 
1688 
  FUNCTION ADD_UVEC(l_vec : STD_LOGIC_VECTOR; r_vec : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
1689 
  BEGIN
1690 
    RETURN ADD_UVEC(l_vec, r_vec, l_vec'LENGTH);
1691 
  END;
1692 
 
1693 
  FUNCTION SUB_UVEC(l_vec : STD_LOGIC_VECTOR; r_vec : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
1694 
  BEGIN
1695 
    RETURN SUB_UVEC(l_vec, r_vec, l_vec'LENGTH);
1696 
  END;
1697 
 
1698 
  FUNCTION COMPLEX_MULT_REAL(a_re, a_im, b_re, b_im : INTEGER) RETURN INTEGER IS
1699 
  BEGIN
1700 
    RETURN (a_re*b_re - a_im*b_im);
1701 
  END;
1702 
 
1703 
  FUNCTION COMPLEX_MULT_IMAG(a_re, a_im, b_re, b_im : INTEGER) RETURN INTEGER IS
1704 
  BEGIN
1705 
    RETURN (a_im*b_re + a_re*b_im);
1706 
  END;
1707 
 
1708 
  FUNCTION SHIFT_UVEC(vec : STD_LOGIC_VECTOR; shift : INTEGER) RETURN STD_LOGIC_VECTOR IS
1709 
  BEGIN
1710 
    IF shift < 0 THEN
1711 
      RETURN STD_LOGIC_VECTOR(SHIFT_LEFT(UNSIGNED(vec), -shift));  -- fill zeros from right
1712 
    ELSE
1713 
      RETURN STD_LOGIC_VECTOR(SHIFT_RIGHT(UNSIGNED(vec), shift));  -- fill zeros from left
1714 
    END IF;
1715 
  END;
1716 
 
1717 
  FUNCTION SHIFT_SVEC(vec : STD_LOGIC_VECTOR; shift : INTEGER) RETURN STD_LOGIC_VECTOR IS
1718 
  BEGIN
1719 
    IF shift < 0 THEN
1720 
      RETURN STD_LOGIC_VECTOR(SHIFT_LEFT(SIGNED(vec), -shift));  -- same as SHIFT_LEFT for UNSIGNED
1721 
    ELSE
1722 
      RETURN STD_LOGIC_VECTOR(SHIFT_RIGHT(SIGNED(vec), shift));  -- extend sign
1723 
    END IF;
1724 
  END;
1725 
 
1726 
  --
1727 
  -- offset_binary() : maps offset binary to or from two-complement binary.
1728 
  --
1729 
  --   National ADC08DC1020     offset binary     two-complement binary
1730 
  --   + full scale =  127.5 :  11111111 = 255     127 = 01111111
1731 
  --     ...
1732 
  --   +            =   +0.5 :  10000000 = 128       0 = 00000000
1733 
  --   0
1734 
  --   -            =   -0.5 :  01111111 = 127      -1 = 11111111
1735 
  --     ...
1736 
  --   - full scale = -127.5 :  00000000 =   0    -128 = 10000000
1737 
  --
1738 
  -- To map between the offset binary and two complement binary involves
1739 
  -- adding 128 to the binary value or equivalently inverting the sign bit.
1740 
  -- The offset_binary() mapping can be done and undone both ways.
1741 
  -- The offset_binary() mapping to two-complement binary yields a DC offset
1742 
  -- of -0.5 Lsb.
1743 
  FUNCTION offset_binary(a : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
1744 
    VARIABLE v_res : STD_LOGIC_VECTOR(a'LENGTH-1 DOWNTO 0) := a;
1745 
  BEGIN
1746 
   v_res(v_res'HIGH) := NOT v_res(v_res'HIGH);  -- invert MSbit to get to from offset binary to two's complement, or vice versa
1747 
   RETURN v_res;
1748 
  END;
1749 
 
1750 
  FUNCTION truncate(vec : STD_LOGIC_VECTOR; n : NATURAL) RETURN STD_LOGIC_VECTOR IS
1751 
    CONSTANT c_vec_w   : NATURAL := vec'LENGTH;
1752 
    CONSTANT c_trunc_w : NATURAL := c_vec_w-n;
1753 
    VARIABLE v_vec     : STD_LOGIC_VECTOR(c_vec_w-1 DOWNTO 0) := vec;
1754 
    VARIABLE v_res     : STD_LOGIC_VECTOR(c_trunc_w-1 DOWNTO 0);
1755 
  BEGIN
1756 
   v_res := v_vec(c_vec_w-1 DOWNTO n);  -- keep MS part
1757 
   RETURN v_res;
1758 
  END;
1759 
 
1760 
  FUNCTION truncate_and_resize_uvec(vec : STD_LOGIC_VECTOR; n, w : NATURAL) RETURN STD_LOGIC_VECTOR IS
1761 
    CONSTANT c_vec_w   : NATURAL := vec'LENGTH;
1762 
    CONSTANT c_trunc_w : NATURAL := c_vec_w-n;
1763 
    VARIABLE v_trunc   : STD_LOGIC_VECTOR(c_trunc_w-1 DOWNTO 0);
1764 
    VARIABLE v_res     : STD_LOGIC_VECTOR(w-1 DOWNTO 0);
1765 
  BEGIN
1766 
    v_trunc := truncate(vec, n);       -- first keep MS part
1767 
    v_res := RESIZE_UVEC(v_trunc, w);  -- then keep LS part or left extend with '0'
1768 
    RETURN v_res;
1769 
  END;
1770 
 
1771 
  FUNCTION truncate_and_resize_svec(vec : STD_LOGIC_VECTOR; n, w : NATURAL) RETURN STD_LOGIC_VECTOR IS
1772 
    CONSTANT c_vec_w   : NATURAL := vec'LENGTH;
1773 
    CONSTANT c_trunc_w : NATURAL := c_vec_w-n;
1774 
    VARIABLE v_trunc   : STD_LOGIC_VECTOR(c_trunc_w-1 DOWNTO 0);
1775 
    VARIABLE v_res     : STD_LOGIC_VECTOR(w-1 DOWNTO 0);
1776 
  BEGIN
1777 
    v_trunc := truncate(vec, n);       -- first keep MS part
1778 
    v_res := RESIZE_SVEC(v_trunc, w);  -- then keep sign bit and LS part or left extend sign bit
1779 
    RETURN v_res;
1780 
  END;
1781 
 
1782 
  FUNCTION scale(vec : STD_LOGIC_VECTOR; n: NATURAL) RETURN STD_LOGIC_VECTOR IS
1783 
    CONSTANT c_vec_w   : NATURAL := vec'LENGTH;
1784 
    CONSTANT c_scale_w : NATURAL := c_vec_w+n;
1785 
    VARIABLE v_res     : STD_LOGIC_VECTOR(c_scale_w-1 DOWNTO 0) := (OTHERS=>'0');
1786 
  BEGIN
1787 
    v_res(c_scale_w-1 DOWNTO n) := vec;  -- scale by adding n zero bits at the right
1788 
    RETURN v_res;
1789 
  END;
1790 
 
1791 
  FUNCTION scale_and_resize_uvec(vec : STD_LOGIC_VECTOR; n, w : NATURAL) RETURN STD_LOGIC_VECTOR IS
1792 
    CONSTANT c_vec_w   : NATURAL := vec'LENGTH;
1793 
    CONSTANT c_scale_w : NATURAL := c_vec_w+n;
1794 
    VARIABLE v_scale   : STD_LOGIC_VECTOR(c_scale_w-1 DOWNTO 0) := (OTHERS=>'0');
1795 
    VARIABLE v_res     : STD_LOGIC_VECTOR(w-1 DOWNTO 0);
1796 
  BEGIN
1797 
    v_scale(c_scale_w-1 DOWNTO n) := vec;  -- first scale by adding n zero bits at the right
1798 
    v_res := RESIZE_UVEC(v_scale, w);      -- then keep LS part or left extend with '0'
1799 
    RETURN v_res;
1800 
  END;
1801 
 
1802 
  FUNCTION scale_and_resize_svec(vec : STD_LOGIC_VECTOR; n, w : NATURAL) RETURN STD_LOGIC_VECTOR IS
1803 
    CONSTANT c_vec_w   : NATURAL := vec'LENGTH;
1804 
    CONSTANT c_scale_w : NATURAL := c_vec_w+n;
1805 
    VARIABLE v_scale   : STD_LOGIC_VECTOR(c_scale_w-1 DOWNTO 0) := (OTHERS=>'0');
1806 
    VARIABLE v_res     : STD_LOGIC_VECTOR(w-1 DOWNTO 0);
1807 
  BEGIN
1808 
    v_scale(c_scale_w-1 DOWNTO n) := vec;  -- first scale by adding n zero bits at the right
1809 
    v_res := RESIZE_SVEC(v_scale, w);      -- then keep LS part or left extend sign bit
1810 
    RETURN v_res;
1811 
  END;
1812 
 
1813 
  FUNCTION truncate_or_resize_uvec(vec : STD_LOGIC_VECTOR; b : BOOLEAN; w : NATURAL) RETURN STD_LOGIC_VECTOR IS
1814 
    CONSTANT c_vec_w : NATURAL := vec'LENGTH;
1815 
    VARIABLE c_n     : INTEGER := c_vec_w-w;
1816 
    VARIABLE v_res   : STD_LOGIC_VECTOR(w-1 DOWNTO 0);
1817 
  BEGIN
1818 
    IF b=TRUE AND c_n>0 THEN
1819 
      v_res := truncate_and_resize_uvec(vec, c_n, w);
1820 
    ELSE
1821 
      v_res := RESIZE_UVEC(vec, w);
1822 
    END IF;
1823 
    RETURN v_res;
1824 
  END;
1825 
 
1826 
  FUNCTION truncate_or_resize_svec(vec : STD_LOGIC_VECTOR; b : BOOLEAN; w : NATURAL) RETURN STD_LOGIC_VECTOR IS
1827 
    CONSTANT c_vec_w : NATURAL := vec'LENGTH;
1828 
    VARIABLE c_n     : INTEGER := c_vec_w-w;
1829 
    VARIABLE v_res   : STD_LOGIC_VECTOR(w-1 DOWNTO 0);
1830 
  BEGIN
1831 
    IF b=TRUE AND c_n>0 THEN
1832 
      v_res := truncate_and_resize_svec(vec, c_n, w);
1833 
    ELSE
1834 
      v_res := RESIZE_SVEC(vec, w);
1835 
    END IF;
1836 
    RETURN v_res;
1837 
  END;
1838 
 
1839 
 
1840 
  -- Functions s_round, s_round_up and u_round:
1841 
  --
1842 
  -- . The returned output width is input width - n.
1843 
  -- . If n=0 then the return value is the same as the input value so only
1844 
  --   wires (NOP, no operation).
1845 
  -- . Both have the same implementation but different c_max and c_clip values.
1846 
  -- . Round up for unsigned so +2.5 becomes 3
1847 
  -- . Round away from zero for signed so round up for positive and round down for negative, so +2.5 becomes 3 and -2.5 becomes -3.
1848 
  -- . Round away from zero is also used by round() in Matlab, Python, TCL
1849 
  -- . Rounding up implies adding 0.5 and then truncation, use clip = TRUE to
1850 
  --   clip the potential overflow due to adding 0.5 to +max.
1851 
  -- . For negative values overflow due to rounding can not occur, because c_half-1 >= 0 for n>0
1852 
  -- . If the input comes from a product and is rounded to the input width then
1853 
  --   clip can safely be FALSE, because e.g. for unsigned 4b*4b=8b->4b the
1854 
  --   maximum product is 15*15=225 <= 255-8, and for signed 4b*4b=8b->4b the
1855 
  --   maximum product is -8*-8=+64 <= 127-8, so wrapping due to rounding
1856 
  --   overflow will never occur.
1857 
 
1858 
  FUNCTION s_round(vec : STD_LOGIC_VECTOR; n : NATURAL; clip : BOOLEAN) RETURN STD_LOGIC_VECTOR IS
1859 
    -- Use SIGNED to avoid NATURAL (32 bit range) overflow error
1860 
    CONSTANT c_in_w  : NATURAL := vec'LENGTH;
1861 
    CONSTANT c_out_w : NATURAL := vec'LENGTH - n;
1862 
    CONSTANT c_one   : SIGNED(c_in_w-1 DOWNTO 0) := TO_SIGNED(1, c_in_w);
1863 
    CONSTANT c_half  : SIGNED(c_in_w-1 DOWNTO 0) := SHIFT_LEFT(c_one, n-1);                            -- = 2**(n-1)
1864 
    CONSTANT c_max   : SIGNED(c_in_w-1 DOWNTO 0) := SIGNED('0' & c_slv1(c_in_w-2 DOWNTO 0)) - c_half;  -- = 2**(c_in_w-1)-1 - c_half
1865 
    CONSTANT c_clip  : SIGNED(c_out_w-1 DOWNTO 0) := SIGNED('0' & c_slv1(c_out_w-2 DOWNTO 0));         -- = 2**(c_out_w-1)-1
1866 
    VARIABLE v_in    : SIGNED(c_in_w-1 DOWNTO 0);
1867 
    VARIABLE v_out   : SIGNED(c_out_w-1 DOWNTO 0);
1868 
  BEGIN
1869 
    v_in := SIGNED(vec);
1870 
    IF n > 0 THEN
1871 
      IF clip = TRUE AND v_in > c_max THEN
1872 
        v_out := c_clip;                                              -- Round clip to maximum positive to avoid wrap to negative
1873 
      ELSE
1874 
        IF vec(vec'HIGH)='0' THEN
1875 
          v_out := RESIZE_NUM(SHIFT_RIGHT(v_in + c_half + 0, n), c_out_w);  -- Round up for positive
1876 
        ELSE
1877 
          v_out := RESIZE_NUM(SHIFT_RIGHT(v_in + c_half - 1, n), c_out_w);  -- Round down for negative
1878 
        END IF;
1879 
      END IF;
1880 
    ELSE
1881 
      v_out := RESIZE_NUM(v_in, c_out_w);                             -- NOP
1882 
    END IF;
1883 
    RETURN STD_LOGIC_VECTOR(v_out);
1884 
  END;
1885 
 
1886 
  FUNCTION s_round(vec : STD_LOGIC_VECTOR; n : NATURAL) RETURN STD_LOGIC_VECTOR IS
1887 
  BEGIN
1888 
    RETURN s_round(vec, n, FALSE);  -- no round clip
1889 
  END;
1890 
 
1891 
  -- An alternative is to always round up, also for negative numbers (i.e. s_round_up = u_round).
1892 
  FUNCTION s_round_up(vec : STD_LOGIC_VECTOR; n : NATURAL; clip : BOOLEAN) RETURN STD_LOGIC_VECTOR IS
1893 
  BEGIN
1894 
    RETURN u_round(vec, n, clip);
1895 
  END;
1896 
 
1897 
  FUNCTION s_round_up(vec : STD_LOGIC_VECTOR; n : NATURAL) RETURN STD_LOGIC_VECTOR IS
1898 
  BEGIN
1899 
    RETURN u_round(vec, n, FALSE);  -- no round clip
1900 
  END;
1901 
 
1902 
  -- Unsigned numbers are round up (almost same as s_round, but without the else on negative vec)
1903 
  FUNCTION u_round(vec : STD_LOGIC_VECTOR; n : NATURAL; clip : BOOLEAN ) RETURN STD_LOGIC_VECTOR IS
1904 
    -- Use UNSIGNED to avoid NATURAL (32 bit range) overflow error
1905 
    CONSTANT c_in_w  : NATURAL := vec'LENGTH;
1906 
    CONSTANT c_out_w : NATURAL := vec'LENGTH - n;
1907 
    CONSTANT c_one   : UNSIGNED(c_in_w-1 DOWNTO 0) := TO_UNSIGNED(1, c_in_w);
1908 
    CONSTANT c_half  : UNSIGNED(c_in_w-1 DOWNTO 0) := SHIFT_LEFT(c_one, n-1);                        -- = 2**(n-1)
1909 
    CONSTANT c_max   : UNSIGNED(c_in_w-1 DOWNTO 0) := UNSIGNED(c_slv1(c_in_w-1 DOWNTO 0)) - c_half;  -- = 2**c_in_w-1 - c_half
1910 
    CONSTANT c_clip  : UNSIGNED(c_out_w-1 DOWNTO 0) := UNSIGNED(c_slv1(c_out_w-1 DOWNTO 0));         -- = 2**c_out_w-1
1911 
    VARIABLE v_in    : UNSIGNED(c_in_w-1 DOWNTO 0);
1912 
    VARIABLE v_out   : UNSIGNED(c_out_w-1 DOWNTO 0);
1913 
  BEGIN
1914 
    v_in := UNSIGNED(vec);
1915 
    IF n > 0 THEN
1916 
      IF clip = TRUE AND v_in > c_max THEN
1917 
        v_out := c_clip;                                              -- Round clip to +max to avoid wrap to 0
1918 
      ELSE
1919 
        v_out := RESIZE_NUM(SHIFT_RIGHT(v_in + c_half, n), c_out_w);  -- Round up
1920 
      END IF;
1921 
    ELSE
1922 
      v_out := RESIZE_NUM(v_in, c_out_w);                             -- NOP
1923 
    END IF;
1924 
    RETURN STD_LOGIC_VECTOR(v_out);
1925 
  END;
1926 
 
1927 
  FUNCTION u_round(vec : STD_LOGIC_VECTOR; n : NATURAL) RETURN STD_LOGIC_VECTOR IS
1928 
  BEGIN
1929 
    RETURN u_round(vec, n, FALSE);  -- no round clip
1930 
  END;
1931 9 danv 
 
1932 
  FUNCTION u_to_s(u : NATURAL; w : NATURAL) RETURN INTEGER IS
1933 
    VARIABLE v_u : STD_LOGIC_VECTOR(31 DOWNTO 0) := TO_UVEC(u, 32);  -- via 32 bit word to avoid NUMERIC_STD.TO_SIGNED: vector truncated warming
1934 
  BEGIN
1935 
    RETURN TO_SINT(v_u(w-1 DOWNTO 0));
1936 
  END;
1937 
 
1938 
  FUNCTION s_to_u(s : INTEGER; w : NATURAL) RETURN NATURAL IS
1939 
    VARIABLE v_s : STD_LOGIC_VECTOR(31 DOWNTO 0) := TO_SVEC(s, 32);  -- via 32 bit word to avoid NUMERIC_STD.TO_SIGNED: vector truncated warming
1940 
  BEGIN
1941 
    RETURN TO_UINT(v_s(w-1 DOWNTO 0));
1942 
  END;
1943 
 
1944 
  FUNCTION u_wrap(u : NATURAL; w : NATURAL) RETURN NATURAL IS
1945 
    VARIABLE v_u : STD_LOGIC_VECTOR(31 DOWNTO 0) := TO_UVEC(u, 32);  -- via 32 bit word to avoid NUMERIC_STD.TO_SIGNED: vector truncated warming
1946 
  BEGIN
1947 
    RETURN TO_UINT(v_u(w-1 DOWNTO 0));
1948 
  END;
1949 6 danv 
 
1950 9 danv 
  FUNCTION s_wrap(s : INTEGER; w : NATURAL) RETURN INTEGER IS
1951 
    VARIABLE v_s : STD_LOGIC_VECTOR(31 DOWNTO 0) := TO_SVEC(s, 32);  -- via 32 bit word to avoid NUMERIC_STD.TO_SIGNED: vector truncated warming
1952 
  BEGIN
1953 
    RETURN TO_SINT(v_s(w-1 DOWNTO 0));
1954 
  END;
1955 6 danv 
 
1956 9 danv 
  FUNCTION u_clip(u : NATURAL; max : NATURAL) RETURN NATURAL IS
1957 
  BEGIN
1958 
    IF u > max THEN
1959 
      RETURN max;
1960 
    ELSE
1961 
      RETURN u;
1962 
    END IF;
1963 
  END;
1964 
 
1965 
  FUNCTION s_clip(s : INTEGER; max : NATURAL; min : INTEGER) RETURN INTEGER IS
1966 
  BEGIN
1967 
    IF s < min THEN
1968 
      RETURN min;
1969 
    ELSE
1970 
      IF s > max THEN
1971 
        RETURN max;
1972 
      ELSE
1973 
        RETURN s;
1974 
      END IF;
1975 
    END IF;
1976 
  END;
1977 
 
1978 
  FUNCTION s_clip(s : INTEGER; max : NATURAL) RETURN INTEGER IS
1979 
  BEGIN
1980 
    RETURN s_clip(s, max, -max);
1981 
  END;
1982 
 
1983 6 danv 
  FUNCTION hton(a : STD_LOGIC_VECTOR; w, sz : NATURAL) RETURN STD_LOGIC_VECTOR IS
1984 
    VARIABLE v_a : STD_LOGIC_VECTOR(a'LENGTH-1 DOWNTO 0) := a;  -- map a to range [h:0]
1985 
    VARIABLE v_b : STD_LOGIC_VECTOR(a'LENGTH-1 DOWNTO 0) := a;  -- default b = a
1986 
    VARIABLE vL  : NATURAL;
1987 
    VARIABLE vK  : NATURAL;
1988 
  BEGIN
1989 
    -- Note:
1990 
    -- . if sz = 1          then v_b = v_a
1991 
    -- . if a'LENGTH > sz*w then v_b(a'LENGTH:sz*w) = v_a(a'LENGTH:sz*w)
1992 
    FOR vL IN 0 TO sz-1 LOOP
1993 
      vK := sz-1 - vL;
1994 
      v_b((vL+1)*w-1 DOWNTO vL*w) := v_a((vK+1)*w-1 DOWNTO vK*w);
1995 
    END LOOP;
1996 
    RETURN v_b;
1997 
  END FUNCTION;
1998 
 
1999 
  FUNCTION hton(a : STD_LOGIC_VECTOR; sz : NATURAL) RETURN STD_LOGIC_VECTOR IS
2000 
  BEGIN
2001 
    RETURN hton(a, c_byte_w, sz);  -- symbol width w = c_byte_w = 8
2002 
  END FUNCTION;
2003 
 
2004 
  FUNCTION hton(a : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
2005 
    CONSTANT c_sz : NATURAL := a'LENGTH/ c_byte_w;
2006 
  BEGIN
2007 
    RETURN hton(a, c_byte_w, c_sz);  -- symbol width w = c_byte_w = 8
2008 
  END FUNCTION;
2009 
 
2010 
  FUNCTION ntoh(a : STD_LOGIC_VECTOR; sz : NATURAL) RETURN STD_LOGIC_VECTOR IS
2011 
  BEGIN
2012 
    RETURN hton(a, sz);  -- i.e. ntoh() = hton()
2013 
  END FUNCTION;
2014 
 
2015 
  FUNCTION ntoh(a : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
2016 
  BEGIN
2017 
    RETURN hton(a);  -- i.e. ntoh() = hton()
2018 
  END FUNCTION;
2019 
 
2020 
  FUNCTION flip(a : STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
2021 
    VARIABLE v_a : STD_LOGIC_VECTOR(a'LENGTH-1 DOWNTO 0) := a;
2022 
    VARIABLE v_b : STD_LOGIC_VECTOR(a'LENGTH-1 DOWNTO 0);
2023 
  BEGIN
2024 
    FOR I IN v_a'RANGE LOOP
2025 
      v_b(a'LENGTH-1-I) := v_a(I);
2026 
    END LOOP;
2027 
    RETURN v_b;
2028 
  END;
2029 
 
2030 
  FUNCTION flip(a, w : NATURAL) RETURN NATURAL IS
2031 
  BEGIN
2032 
    RETURN TO_UINT(flip(TO_UVEC(a, w)));
2033 
  END;
2034 
 
2035 
  FUNCTION flip(a : t_slv_32_arr) RETURN t_slv_32_arr IS
2036 
    VARIABLE v_a : t_slv_32_arr(a'LENGTH-1 DOWNTO 0) := a;
2037 
    VARIABLE v_b : t_slv_32_arr(a'LENGTH-1 DOWNTO 0);
2038 
  BEGIN
2039 
    FOR I IN v_a'RANGE LOOP
2040 
      v_b(a'LENGTH-1-I) := v_a(I);
2041 
    END LOOP;
2042 
    RETURN v_b;
2043 
  END;
2044 
 
2045 
  FUNCTION flip(a : t_integer_arr) RETURN t_integer_arr IS
2046 
    VARIABLE v_a : t_integer_arr(a'LENGTH-1 DOWNTO 0) := a;
2047 
    VARIABLE v_b : t_integer_arr(a'LENGTH-1 DOWNTO 0);
2048 
  BEGIN
2049 
    FOR I IN v_a'RANGE LOOP
2050 
      v_b(a'LENGTH-1-I) := v_a(I);
2051 
    END LOOP;
2052 
    RETURN v_b;
2053 
  END;
2054 
 
2055 
  FUNCTION flip(a : t_natural_arr) RETURN t_natural_arr IS
2056 
    VARIABLE v_a : t_natural_arr(a'LENGTH-1 DOWNTO 0) := a;
2057 
    VARIABLE v_b : t_natural_arr(a'LENGTH-1 DOWNTO 0);
2058 
  BEGIN
2059 
    FOR I IN v_a'RANGE LOOP
2060 
      v_b(a'LENGTH-1-I) := v_a(I);
2061 
    END LOOP;
2062 
    RETURN v_b;
2063 
  END;
2064 
 
2065 
  FUNCTION flip(a : t_nat_natural_arr) RETURN t_nat_natural_arr IS
2066 
    VARIABLE v_a : t_nat_natural_arr(a'LENGTH-1 DOWNTO 0) := a;
2067 
    VARIABLE v_b : t_nat_natural_arr(a'LENGTH-1 DOWNTO 0);
2068 
  BEGIN
2069 
    FOR I IN v_a'RANGE LOOP
2070 
      v_b(a'LENGTH-1-I) := v_a(I);
2071 
    END LOOP;
2072 
    RETURN v_b;
2073 
  END;
2074 
 
2075 
  FUNCTION transpose(a : STD_LOGIC_VECTOR; row, col : NATURAL) RETURN STD_LOGIC_VECTOR IS
2076 
    VARIABLE vIn  : STD_LOGIC_VECTOR(a'LENGTH-1 DOWNTO 0);
2077 
    VARIABLE vOut : STD_LOGIC_VECTOR(a'LENGTH-1 DOWNTO 0);
2078 
  BEGIN
2079 
    vIn  := a;    -- map input vector to h:0 range
2080 
    vOut := vIn;  -- default leave any unused MSbits the same
2081 
    FOR J IN 0 TO row-1 LOOP
2082 
      FOR I IN 0 TO col-1 LOOP
2083 
        vOut(J*col + I) := vIn(I*row + J);  -- transpose vector, map input index [i*row+j] to output index [j*col+i]
2084 
      END LOOP;
2085 
    END LOOP;
2086 
    RETURN vOut;
2087 
  END FUNCTION;
2088 
 
2089 
  FUNCTION transpose(a, row, col : NATURAL) RETURN NATURAL IS  -- transpose index a = [i*row+j] to output index [j*col+i]
2090 
    VARIABLE vI  : NATURAL;
2091 
    VARIABLE vJ  : NATURAL;
2092 
  BEGIN
2093 
    vI := a / row;
2094 
    vJ := a MOD row;
2095 
    RETURN vJ * col + vI;
2096 
  END;
2097 
 
2098 
  FUNCTION split_w(input_w: NATURAL; min_out_w: NATURAL; max_out_w: NATURAL) RETURN NATURAL IS -- Calculate input_w in multiples as close as possible to max_out_w
2099 
    -- Examples: split_w(256, 8, 32) = 32;  split_w(16, 8, 32) = 16; split_w(72, 8, 32) = 18;    -- Input_w must be multiple of 2.
2100 
    VARIABLE r: NATURAL;
2101 
  BEGIN
2102 
    r := input_w;
2103 
    FOR i IN 1 TO ceil_log2(input_w) LOOP -- Useless to divide the number beyond this
2104 
      IF r <= max_out_w AND r >= min_out_w THEN
2105 
        RETURN r;
2106 
      ELSIF i = ceil_log2(input_w) THEN -- last iteration
2107 
        RETURN 0; -- Indicates wrong values were used
2108 
      END IF;
2109 
      r := r / 2;
2110 
    END LOOP;
2111 
  END;
2112 
 
2113 
  FUNCTION pad(str: STRING; width: NATURAL; pad_char: CHARACTER) RETURN STRING IS
2114 
    VARIABLE v_str : STRING(1 TO width) := (OTHERS => pad_char);
2115 
  BEGIN
2116 
    v_str(width-str'LENGTH+1 TO width) := str;
2117 
    RETURN v_str;
2118 
  END;
2119 
 
2120 
  FUNCTION slice_up(str: STRING; width: NATURAL; i: NATURAL) RETURN STRING IS
2121 
  BEGIN
2122 
    RETURN str(i*width+1 TO (i+1)*width);
2123 
  END;
2124 
 
2125 
  -- If the input value is not a multiple of the desired width, the return value is padded with
2126 
  -- the passed pad value. E.g. if input='10' and desired width is 4, return value is '0010'.
2127 
  FUNCTION slice_up(str: STRING; width: NATURAL; i: NATURAL; pad_char: CHARACTER) RETURN STRING IS
2128 
    VARIABLE padded_str : STRING(1 TO width) := (OTHERS=>'0');
2129 
  BEGIN
2130 
    padded_str := pad(str(i*width+1 TO (i+1)*width), width, '0');
2131 
    RETURN padded_str;
2132 
  END;
2133 
 
2134 
  FUNCTION slice_dn(str: STRING; width: NATURAL; i: NATURAL) RETURN STRING IS
2135 
  BEGIN
2136 
    RETURN str((i+1)*width-1 DOWNTO i*width);
2137 
  END;
2138 
 
2139 
 
2140 
  FUNCTION nat_arr_to_concat_slv(nat_arr: t_natural_arr; nof_elements: NATURAL) RETURN STD_LOGIC_VECTOR IS
2141 
    VARIABLE v_concat_slv : STD_LOGIC_VECTOR(nof_elements*32-1 DOWNTO 0) := (OTHERS=>'0');
2142 
  BEGIN
2143 
    FOR i IN 0 TO nof_elements-1 LOOP
2144 
      v_concat_slv(i*32+32-1 DOWNTO i*32) :=  TO_UVEC(nat_arr(i), 32);
2145 
    END LOOP;
2146 
    RETURN v_concat_slv;
2147 
  END;
2148 
 
2149 
 
2150 
  ------------------------------------------------------------------------------
2151 
  -- common_fifo_*
2152 
  ------------------------------------------------------------------------------
2153 
 
2154 
  PROCEDURE proc_common_fifo_asserts (CONSTANT c_fifo_name   : IN STRING;
2155 
                                      CONSTANT c_note_is_ful : IN BOOLEAN;
2156 
                                      CONSTANT c_fail_rd_emp : IN BOOLEAN;
2157 
                                      SIGNAL   wr_rst        : IN STD_LOGIC;
2158 
                                      SIGNAL   wr_clk        : IN STD_LOGIC;
2159 
                                      SIGNAL   wr_full       : IN STD_LOGIC;
2160 
                                      SIGNAL   wr_en         : IN STD_LOGIC;
2161 
                                      SIGNAL   rd_clk        : IN STD_LOGIC;
2162 
                                      SIGNAL   rd_empty      : IN STD_LOGIC;
2163 
                                      SIGNAL   rd_en         : IN STD_LOGIC) IS
2164 
  BEGIN
2165 
    -- c_fail_rd_emp : when TRUE report FAILURE when read from an empty FIFO, important when FIFO rd_val is not used
2166 
    -- c_note_is_ful : when TRUE report NOTE when FIFO goes full, to note that operation is on the limit
2167 
    -- FIFO overflow is always reported as FAILURE
2168 
 
2169 
    -- The FIFO wr_full goes high at reset to indicate that it can not be written and it goes low a few cycles after reset.
2170 
    -- Therefore only check on wr_full going high when wr_rst='0'.
2171 
 
2172 
    --synthesis translate_off
2173 
    ASSERT NOT(c_fail_rd_emp=TRUE AND rising_edge(rd_clk)  AND rd_empty='1' AND rd_en='1')  REPORT c_fifo_name & " : read from empty fifo occurred!" SEVERITY FAILURE;
2174 
    ASSERT NOT(c_note_is_ful=TRUE AND rising_edge(wr_full) AND wr_rst='0')                  REPORT c_fifo_name & " : fifo is full now"               SEVERITY NOTE;
2175 
    ASSERT NOT(                       rising_edge(wr_clk)  AND wr_full='1'  AND wr_en='1')  REPORT c_fifo_name & " : fifo overflow occurred!"        SEVERITY FAILURE;
2176 
    --synthesis translate_on
2177 
  END PROCEDURE proc_common_fifo_asserts;
2178 
 
2179 
 
2180 
  ------------------------------------------------------------------------------
2181 
  -- common_fanout_tree
2182 
  ------------------------------------------------------------------------------
2183 
 
2184 
  FUNCTION func_common_fanout_tree_pipelining(c_nof_stages, c_nof_output_per_cell, c_nof_output : NATURAL;
2185 
                                              c_cell_pipeline_factor_arr, c_cell_pipeline_arr : t_natural_arr) RETURN t_natural_arr IS
2186 
    CONSTANT k_cell_pipeline_factor_arr : t_natural_arr(c_nof_stages-1 DOWNTO 0) := c_cell_pipeline_factor_arr;
2187 
    CONSTANT k_cell_pipeline_arr        : t_natural_arr(c_nof_output_per_cell-1 DOWNTO 0) := c_cell_pipeline_arr;
2188 
    VARIABLE v_stage_pipeline_arr       : t_natural_arr(c_nof_output-1 DOWNTO 0) := (OTHERS=>0);
2189 
    VARIABLE v_prev_stage_pipeline_arr  : t_natural_arr(c_nof_output-1 DOWNTO 0) := (OTHERS=>0);
2190 
  BEGIN
2191 
    loop_stage : FOR j IN 0 TO c_nof_stages-1 LOOP
2192 
      v_prev_stage_pipeline_arr := v_stage_pipeline_arr;
2193 
      loop_cell : FOR i IN 0 TO c_nof_output_per_cell**j-1 LOOP
2194 
        v_stage_pipeline_arr((i+1)*c_nof_output_per_cell-1 DOWNTO i*c_nof_output_per_cell) := v_prev_stage_pipeline_arr(i) + (k_cell_pipeline_factor_arr(j) * k_cell_pipeline_arr);
2195 
      END LOOP;
2196 
    END LOOP;
2197 
    RETURN v_stage_pipeline_arr;
2198 
  END FUNCTION func_common_fanout_tree_pipelining;
2199 
 
2200 
 
2201 
  ------------------------------------------------------------------------------
2202 
  -- common_reorder_symbol
2203 
  ------------------------------------------------------------------------------
2204 
 
2205 
  -- Determine whether the stage I and row J index refer to any (active or redundant) 2-input reorder cell instantiation
2206 
  FUNCTION func_common_reorder2_is_there(I, J : NATURAL) RETURN BOOLEAN IS
2207 
    VARIABLE v_odd  : BOOLEAN;
2208 
    VARIABLE v_even : BOOLEAN;
2209 
  BEGIN
2210 
    v_odd  := (I MOD 2 = 1) AND (J MOD 2 = 1);  -- for odd  stage at each odd  row
2211 
    v_even := (I MOD 2 = 0) AND (J MOD 2 = 0);  -- for even stage at each even row
2212 
    RETURN v_odd OR v_even;
2213 
  END func_common_reorder2_is_there;
2214 
 
2215 
  -- Determine whether the stage I and row J index refer to an active 2-input reorder cell instantiation in a reorder network with N stages
2216 
  FUNCTION func_common_reorder2_is_active(I, J, N : NATURAL) RETURN BOOLEAN IS
2217 
    VARIABLE v_inst : BOOLEAN;
2218 
    VARIABLE v_act  : BOOLEAN;
2219 
  BEGIN
2220 
    v_inst := func_common_reorder2_is_there(I, J);
2221 
    v_act  := (I > 0) AND (I <= N) AND (J > 0) AND (J < N);
2222 
    RETURN v_inst AND v_act;
2223 
  END func_common_reorder2_is_active;
2224 
 
2225 
  -- Get the index K in the select setting array for the reorder2 cell on stage I and row J in a reorder network with N stages
2226 
  FUNCTION func_common_reorder2_get_select_index(I, J, N : NATURAL) RETURN INTEGER IS
2227 
    CONSTANT c_nof_reorder2_per_odd_stage  : NATURAL := N/2;
2228 
    CONSTANT c_nof_reorder2_per_even_stage : NATURAL := (N-1)/2;
2229 
    VARIABLE v_nof_odd_stages  : NATURAL;
2230 
    VARIABLE v_nof_even_stages : NATURAL;
2231 
    VARIABLE v_offset          : NATURAL;
2232 
    VARIABLE v_K               : INTEGER;
2233 
  BEGIN
2234 
    -- for I, J that do not refer to an reorder cell instance for -1 as dummy return value.
2235 
    -- for the redundant two port reorder cells at the border rows for -1 to indicate that the cell should pass on the input.
2236 
    v_K := -1;
2237 
    IF func_common_reorder2_is_active(I, J, N) THEN
2238 
      -- for the active two port reorder cells use the setting at index v_K from the select setting array
2239 
      v_nof_odd_stages  :=  I/2;
2240 
      v_nof_even_stages := (I-1)/2;
2241 
      v_offset          := (J-1)/2;  -- suits both odd stage and even stage
2242 
      v_K := v_nof_odd_stages * c_nof_reorder2_per_odd_stage + v_nof_even_stages * c_nof_reorder2_per_even_stage + v_offset;
2243 
    END IF;
2244 
    RETURN v_K;
2245 
  END func_common_reorder2_get_select_index;
2246 
 
2247 
  -- Get the select setting for the reorder2 cell on stage I and row J in a reorder network with N stages
2248 
  FUNCTION func_common_reorder2_get_select(I, J, N : NATURAL; select_arr : t_natural_arr) RETURN NATURAL IS
2249 
    CONSTANT c_nof_select : NATURAL := select_arr'LENGTH;
2250 
    CONSTANT c_select_arr : t_natural_arr(c_nof_select-1 DOWNTO 0) := select_arr;  -- force range downto 0
2251 
    VARIABLE v_sel        : NATURAL;
2252 
    VARIABLE v_K          : INTEGER;
2253 
  BEGIN
2254 
    v_sel := 0;
2255 
    v_K := func_common_reorder2_get_select_index(I, J, N);
2256 
    IF v_K>=0 THEN
2257 
      v_sel := c_select_arr(v_K);
2258 
    END IF;
2259 
    RETURN v_sel;
2260 
  END func_common_reorder2_get_select;
2261 
 
2262 
  -- Determine the inverse of a reorder network by using two reorder networks in series
2263 
  FUNCTION func_common_reorder2_inverse_select(N : NATURAL; select_arr : t_natural_arr) RETURN t_natural_arr IS
2264 
    CONSTANT c_nof_select      : NATURAL := select_arr'LENGTH;
2265 
    CONSTANT c_select_arr      : t_natural_arr(c_nof_select-1 DOWNTO 0) := select_arr;  -- force range downto 0
2266 
    VARIABLE v_sel             : NATURAL;
2267 
    VARIABLE v_Ki              : INTEGER;
2268 
    VARIABLE v_Ii              : NATURAL;
2269 
    VARIABLE v_inverse_arr     : t_natural_arr(2*c_nof_select-1 DOWNTO 0) := (OTHERS=>0);  -- default set identity for the reorder2 cells in both reorder instances
2270 
  BEGIN
2271 
    -- the inverse select consists of inverse_in reorder and inverse_out reorder in series
2272 
    IF N MOD 2 = 1 THEN
2273 
      -- N is odd so only need to fill in the inverse_in reorder, the inverse_out reorder remains at default pass on
2274 
      FOR I IN 1 TO N LOOP
2275 
        FOR J IN 0 TO N-1 LOOP
2276 
          -- get the DUT setting
2277 
          v_sel := func_common_reorder2_get_select(I, J, N, c_select_arr);
2278 
          -- map DUT I to inverse v_Ii stage index and determine the index for the inverse setting
2279 
          v_Ii := 1+N-I;
2280 
          v_Ki := func_common_reorder2_get_select_index(v_Ii, J, N);
2281 
          IF v_Ki>=0 THEN
2282 
            v_inverse_arr(v_Ki) := v_sel;
2283 
          END IF;
2284 
        END LOOP;
2285 
      END LOOP;
2286 
    ELSE
2287 
      -- N is even so only use stage 1 of the inverse_out reorder, the other stages remain at default pass on
2288 
      FOR K IN 0 TO N/2-1 LOOP
2289 
         v_Ki := c_nof_select + K;  -- stage 1 of the inverse_out reorder
2290 
         v_inverse_arr(v_Ki) := c_select_arr(K);
2291 
      END LOOP;
2292 
      -- N is even so leave stage 1 of the inverse_in reorder at default pass on, and do inverse the other stages
2293 
      FOR I IN 2 TO N LOOP
2294 
        FOR J IN 0 TO N-1 LOOP
2295 
          -- get the DUT setting
2296 
          v_sel := func_common_reorder2_get_select(I, J, N, c_select_arr);
2297 
          -- map DUT I to inverse v_Ii stage index and determine the index for the inverse setting
2298 
          v_Ii := 2+N-I;
2299 
          v_Ki := func_common_reorder2_get_select_index(v_Ii, J, N);
2300 
          IF v_Ki>=0 THEN
2301 
            v_inverse_arr(v_Ki) := v_sel;
2302 
          END IF;
2303 
        END LOOP;
2304 
      END LOOP;
2305 
    END IF;
2306 
    RETURN v_inverse_arr;
2307 
  END func_common_reorder2_inverse_select;
2308 
 
2309 
  ------------------------------------------------------------------------------
2310 
  -- PROCEDURE: Generate faster sample SCLK from digital DCLK for sim only
2311 
  -- Description:
2312 
  --   The SCLK kan be used to serialize Pfactor >= 1 symbols per word and then
2313 
  --   view them in a scope component that is use internally in the design.
2314 
  --   The scope component is only instantiated for simulation, to view the
2315 
  --   serialized symbols, typically with decimal radix and analogue format.
2316 
  --   The scope component will not be synthesized, because the SCLK can not
2317 
  --   be synthesized.
2318 
  --
2319 
  --   Pfactor = 4
2320 
  --            _______         _______         _______         _______
2321 
  --   DCLK ___|       |_______|       |_______|       |_______|       |_______
2322 
  --        ___________________   _   _   _   _   _   _   _   _   _   _   _   _
2323 
  --   SCLK                    |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_|
2324 
  --
2325 
  --   The rising edges of SCLK occur after the rising edge of DCLK, to ensure
2326 
  --   that they all apply to the same wide data word that was clocked by the
2327 
  --   rising edge of the DCLK.
2328 
  ------------------------------------------------------------------------------
2329 
  PROCEDURE proc_common_dclk_generate_sclk(CONSTANT Pfactor : IN    POSITIVE;
2330 
                                           SIGNAL   dclk    : IN    STD_LOGIC;
2331 
                                           SIGNAL   sclk    : INOUT STD_LOGIC) IS
2332 
    VARIABLE v_dperiod : TIME;
2333 
    VARIABLE v_speriod : TIME;
2334 
  BEGIN
2335 
    SCLK <= '1';
2336 
    -- Measure DCLK period
2337 
    WAIT UNTIL rising_edge(DCLK);
2338 
    v_dperiod := NOW;
2339 
    WAIT UNTIL rising_edge(DCLK);
2340 
    v_dperiod := NOW - v_dperiod;
2341 
    v_speriod := v_dperiod / Pfactor;
2342 
    -- Generate Pfactor SCLK periods per DCLK period
2343 
    WHILE TRUE LOOP
2344 
      -- Realign at every DCLK
2345 
      WAIT UNTIL rising_edge(DCLK);
2346 
      -- Create Pfactor SCLK periods within this DCLK period
2347 
      SCLK <= '0';
2348 
      IF Pfactor>1 THEN
2349 
        FOR I IN 0 TO 2*Pfactor-1-2 LOOP
2350 
          WAIT FOR v_speriod/2;
2351 
          SCLK <= NOT SCLK;
2352 
        END LOOP;
2353 
      END IF;
2354 
      WAIT FOR v_speriod/2;
2355 
      SCLK <= '1';
2356 
      -- Wait for next DCLK
2357 
    END LOOP;
2358 
    WAIT;
2359 
  END proc_common_dclk_generate_sclk;
2360 
 
2361 
END common_pkg;
2362 
 

powered by: WebSVN 2.1.0

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