1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
|
-- Values in synthesis.
-- Copyright (C) 2017 Tristan Gingold
--
-- This file is part of GHDL.
--
-- This program is free software; you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation; either version 2 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with this program; if not, write to the Free Software
-- Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
-- MA 02110-1301, USA.
with Ada.Unchecked_Conversion;
with System;
package body Synth.Values is
function To_Bound_Array_Acc is new Ada.Unchecked_Conversion
(System.Address, Bound_Array_Acc);
function To_Type_Acc is new Ada.Unchecked_Conversion
(System.Address, Type_Acc);
function To_Value_Acc is new Ada.Unchecked_Conversion
(System.Address, Value_Acc);
function To_Value_Array_Acc is new Ada.Unchecked_Conversion
(System.Address, Values.Value_Array_Acc);
function Is_Equal (L, R : Value_Acc) return Boolean is
begin
if L.Kind /= R.Kind then
return False;
end if;
case L.Kind is
when Value_Discrete =>
return L.Scal = R.Scal;
when others =>
-- TODO.
raise Internal_Error;
end case;
end Is_Equal;
function Create_Bit_Type return Type_Acc
is
subtype Bit_Type_Type is Type_Type (Type_Bit);
function Alloc is new Areapools.Alloc_On_Pool_Addr (Bit_Type_Type);
begin
return To_Type_Acc (Alloc (Current_Pool, (Kind => Type_Bit)));
end Create_Bit_Type;
function Create_Discrete_Type (Rng : Discrete_Range_Type) return Type_Acc
is
subtype Discrete_Type_Type is Type_Type (Type_Discrete);
function Alloc is new Areapools.Alloc_On_Pool_Addr (Discrete_Type_Type);
begin
return To_Type_Acc (Alloc (Current_Pool, (Kind => Type_Discrete,
Drange => Rng)));
end Create_Discrete_Type;
function Create_Float_Type (Rng : Float_Range_Type) return Type_Acc
is
subtype Float_Type_Type is Type_Type (Type_Float);
function Alloc is new Areapools.Alloc_On_Pool_Addr (Float_Type_Type);
begin
return To_Type_Acc (Alloc (Current_Pool, (Kind => Type_Float,
Frange => Rng)));
end Create_Float_Type;
function Create_Vector_Type (Bnd : Bound_Type; El_Type : Type_Acc)
return Type_Acc
is
subtype Vector_Type_Type is Type_Type (Type_Vector);
function Alloc is new Areapools.Alloc_On_Pool_Addr (Vector_Type_Type);
begin
return To_Type_Acc (Alloc (Current_Pool, (Kind => Type_Vector,
Vbound => Bnd,
Vec_El => El_Type)));
end Create_Vector_Type;
function Create_Vec_Type_By_Length (Len : Width; El : Type_Acc)
return Type_Acc is
begin
return Create_Vector_Type ((Dir => Iir_Downto,
W => 0,
Left => Int32 (Len) - 1,
Right => 0,
Len => Len),
El);
end Create_Vec_Type_By_Length;
function Create_Bound_Array (Ndims : Iir_Index32) return Bound_Array_Acc
is
use System;
subtype Data_Type is Bound_Array (Ndims);
Res : Address;
begin
-- Manually allocate the array to handle large arrays without
-- creating a large temporary value.
Areapools.Allocate
(Current_Pool.all, Res,
Data_Type'Size / Storage_Unit, Data_Type'Alignment);
declare
-- Discard the warnings for no pragma Import as we really want
-- to use the default initialization.
pragma Warnings (Off);
Addr1 : constant Address := Res;
Init : Data_Type;
for Init'Address use Addr1;
pragma Warnings (On);
begin
null;
end;
return To_Bound_Array_Acc (Res);
end Create_Bound_Array;
function Create_Array_Type (Bnd : Bound_Array_Acc; El_Type : Type_Acc)
return Type_Acc
is
subtype Array_Type_Type is Type_Type (Type_Array);
function Alloc is new Areapools.Alloc_On_Pool_Addr (Array_Type_Type);
begin
return To_Type_Acc (Alloc (Current_Pool, (Kind => Type_Array,
Abounds => Bnd,
Arr_El => El_Type)));
end Create_Array_Type;
function Create_Unbounded_Array (El_Type : Type_Acc) return Type_Acc
is
subtype Unbounded_Type_Type is Type_Type (Type_Unbounded_Array);
function Alloc is new Areapools.Alloc_On_Pool_Addr (Unbounded_Type_Type);
begin
return To_Type_Acc (Alloc (Current_Pool, (Kind => Type_Unbounded_Array,
Uarr_El => El_Type)));
end Create_Unbounded_Array;
function Get_Array_Element (Arr_Type : Type_Acc) return Type_Acc is
begin
case Arr_Type.Kind is
when Type_Vector =>
return Arr_Type.Vec_El;
when Type_Array =>
return Arr_Type.Arr_El;
when Type_Unbounded_Array =>
return Arr_Type.Uarr_El;
when others =>
raise Internal_Error;
end case;
end Get_Array_Element;
function Create_Value_Wire (W : Wire_Id; Wtype : Type_Acc) return Value_Acc
is
subtype Value_Type_Wire is Value_Type (Values.Value_Wire);
function Alloc is new Areapools.Alloc_On_Pool_Addr (Value_Type_Wire);
begin
return To_Value_Acc (Alloc (Current_Pool,
(Kind => Value_Wire,
W => W,
Typ => Wtype)));
end Create_Value_Wire;
function Create_Value_Net (N : Net; Ntype : Type_Acc) return Value_Acc
is
subtype Value_Type_Net is Value_Type (Value_Net);
function Alloc is new Areapools.Alloc_On_Pool_Addr (Value_Type_Net);
begin
return To_Value_Acc
(Alloc (Current_Pool,
Value_Type_Net'(Kind => Value_Net, N => N, Typ => Ntype)));
end Create_Value_Net;
function Create_Value_Mux2 (Cond : Value_Acc; T : Value_Acc; F : Value_Acc)
return Value_Acc
is
subtype Value_Type_Mux2 is Value_Type (Value_Mux2);
function Alloc is new Areapools.Alloc_On_Pool_Addr (Value_Type_Mux2);
pragma Assert (F = null or else T.Typ = F.Typ);
begin
return To_Value_Acc
(Alloc (Current_Pool,
(Kind => Value_Mux2,
Typ => T.Typ,
M_Cond => Cond, M_T => T, M_F => F)));
end Create_Value_Mux2;
function Create_Value_Discrete (Val : Int64; Vtype : Type_Acc)
return Value_Acc
is
subtype Value_Type_Discrete is Value_Type (Value_Discrete);
function Alloc is new Areapools.Alloc_On_Pool_Addr (Value_Type_Discrete);
begin
return To_Value_Acc (Alloc (Current_Pool,
(Kind => Value_Discrete, Scal => Val,
Typ => Vtype)));
end Create_Value_Discrete;
function Create_Value_Float (Val : Fp64; Vtype : Type_Acc) return Value_Acc
is
subtype Value_Type_Float is Value_Type (Value_Float);
function Alloc is new Areapools.Alloc_On_Pool_Addr (Value_Type_Float);
begin
return To_Value_Acc (Alloc (Current_Pool,
(Kind => Value_Float,
Typ => Vtype,
Fp => Val)));
end Create_Value_Float;
function Create_Value_Array (Len : Iir_Index32) return Value_Array_Acc
is
use System;
subtype Data_Type is Values.Value_Array_Type (Len);
Res : Address;
begin
-- Manually allocate the array to handle large arrays without
-- creating a large temporary value.
Areapools.Allocate
(Current_Pool.all, Res,
Data_Type'Size / Storage_Unit, Data_Type'Alignment);
declare
-- Discard the warnings for no pragma Import as we really want
-- to use the default initialization.
pragma Warnings (Off);
Addr1 : constant Address := Res;
Init : Data_Type;
for Init'Address use Addr1;
pragma Warnings (On);
begin
null;
end;
return To_Value_Array_Acc (Res);
end Create_Value_Array;
function Create_Value_Array (Bounds : Type_Acc; Arr : Value_Array_Acc)
return Value_Acc
is
subtype Value_Type_Array is Value_Type (Value_Array);
function Alloc is new Areapools.Alloc_On_Pool_Addr (Value_Type_Array);
Res : Value_Acc;
begin
Res := To_Value_Acc (Alloc (Current_Pool,
(Kind => Value_Array,
Arr => Arr, Typ => Bounds)));
return Res;
end Create_Value_Array;
procedure Create_Array_Data (Arr : Value_Acc)
is
Len : Width;
begin
Len := 1;
case Arr.Typ.Kind is
when Type_Array =>
for I in Arr.Typ.Abounds.D'Range loop
Len := Len * Arr.Typ.Abounds.D (I).Len;
end loop;
when Type_Vector =>
Len := Arr.Typ.Vbound.Len;
when others =>
raise Internal_Error;
end case;
Arr.Arr := Create_Value_Array (Iir_Index32 (Len));
end Create_Array_Data;
function Create_Value_Array (Bounds : Type_Acc) return Value_Acc
is
Res : Value_Acc;
begin
Res := Create_Value_Array (Bounds, null);
Create_Array_Data (Res);
return Res;
end Create_Value_Array;
function Create_Value_Instance (Inst : Instance_Id) return Value_Acc
is
subtype Value_Type_Instance is Value_Type (Value_Instance);
function Alloc is new Areapools.Alloc_On_Pool_Addr (Value_Type_Instance);
begin
return To_Value_Acc
(Alloc (Current_Pool,
(Kind => Value_Instance, Instance => Inst, Typ => null)));
end Create_Value_Instance;
function Create_Value_Subtype (Typ : Type_Acc) return Value_Acc
is
subtype Value_Type_Subtype is Value_Type (Value_Subtype);
function Alloc is new Areapools.Alloc_On_Pool_Addr (Value_Type_Subtype);
begin
return To_Value_Acc (Alloc (Current_Pool,
(Kind => Value_Subtype, Typ => Typ)));
end Create_Value_Subtype;
function Copy (Src: in Value_Acc) return Value_Acc
is
Res: Value_Acc;
begin
case Src.Kind is
when Value_Wire =>
Res := Create_Value_Wire (Src.W, Src.Typ);
when others =>
raise Internal_Error;
end case;
return Res;
end Copy;
function Unshare (Src : Value_Acc; Pool : Areapool_Acc)
return Value_Acc
is
Prev_Pool : constant Areapool_Acc := Current_Pool;
Res : Value_Acc;
begin
Current_Pool := Pool;
Res := Copy (Src);
Current_Pool := Prev_Pool;
return Res;
end Unshare;
function Get_Type_Width (Atype : Type_Acc) return Width is
begin
case Atype.Kind is
when Type_Bit =>
return 1;
when Type_Discrete =>
return Atype.Drange.W;
when Type_Vector =>
return Atype.Vbound.Len;
when others =>
raise Internal_Error;
end case;
end Get_Type_Width;
procedure Init is
begin
Instance_Pool := Global_Pool'Access;
Boolean_Type := Create_Bit_Type;
Logic_Type := Create_Bit_Type;
Bit_Type := Create_Bit_Type;
end Init;
end Synth.Values;
|