Debian Codegraph @

prims/verilog/Clash_Sized_Vector.primitives.yaml

raw
1 - BlackBox:
2 name: Clash.Sized.Vector.head
3 kind: Expression
4 type: 'head :: Vec (n + 1) a -> a'
5 template: '~FROMBV[~VAR[vec][0][\~SIZE[~TYP[0]]-1 -: ~SIZE[~TYPO]\]][~TYPO]'
6 workInfo: Never
7 - BlackBox:
8 name: Clash.Sized.Vector.tail
9 kind: Expression
10 type: 'tail :: Vec (n + 1) a -> Vec n a'
11 template: '~VAR[vec][0][~SIZE[~TYPO]-1 : 0]'
12 workInfo: Never
13 - BlackBox:
14 name: Clash.Sized.Vector.last
15 kind: Expression
16 type: Vec (n + 1) a -> a
17 template: ~FROMBV[~VAR[vec][0][\~SIZE[~TYPO]-1:0\]][~TYPO]
18 workInfo: Never
19 - BlackBox:
20 name: Clash.Sized.Vector.init
21 kind: Expression
22 type: Vec (n + 1) a -> Vec n a
23 template: '~VAR[vec][0][~SIZE[~TYP[0]]-1 : ~SIZE[~TYPEL[~TYP[0]]]]'
24 workInfo: Never
25 - BlackBox:
26 name: Clash.Sized.Vector.select
27 kind: Declaration
28 type: |-
29 select :: (CmpNat (i + s) (s * n) ~ GT) -- ARG[0]
30 => SNat f -- ARG[1]
31 -> SNat s -- ARG[2]
32 -> SNat n -- ARG[3]
33 -> Vec i a -- ARG[4]
34 -> Vec n a
35 template: |-
36 // select begin
37 wire ~TYPEL[~TYPO] ~SYM[1] [0:~LENGTH[~TYP[4]]-1];
38 genvar ~GENSYM[i][2];
39 ~GENERATE
40 for (~SYM[2]=0; ~SYM[2] < ~LENGTH[~TYP[4]]; ~SYM[2]=~SYM[2]+1) begin : ~GENSYM[mk_array][3]
41 assign ~SYM[1][(~LENGTH[~TYP[4]]-1)-~SYM[2]] = ~VAR[vec][4][~SYM[2]*~SIZE[~TYPEL[~TYPO]]+:~SIZE[~TYPEL[~TYPO]]];
42 end
43 ~ENDGENERATE
44
45 genvar ~GENSYM[i][4];
46 ~GENERATE
47 for (~SYM[4]=0; ~SYM[4] < ~LIT[3]; ~SYM[4] = ~SYM[4] + 1) begin : ~GENSYM[select][5]
48 assign ~RESULT[(~LIT[3]-1-~SYM[4])*~SIZE[~TYPEL[~TYPO]]+:~SIZE[~TYPEL[~TYPO]]] = ~SYM[1][~LIT[1] + (~LIT[2] * ~SYM[4])];
49 end
50 ~ENDGENERATE
51 // select end
52 workInfo: Never
53 - BlackBox:
54 name: Clash.Sized.Vector.++
55 kind: Expression
56 type: '(++) :: Vec n a -> Vec m a -> Vec (n + m) a'
57 template: '{~ARG[0],~ARG[1]}'
58 workInfo: Never
59 - BlackBox:
60 name: Clash.Sized.Vector.concat
61 kind: Expression
62 type: 'concat :: Vec n (Vec m a) -> Vec (n * m) a'
63 template: ~ARG[0]
64 workInfo: Never
65 - BlackBox:
66 name: Clash.Sized.Vector.splitAt
67 kind: Expression
68 type: 'splitAt :: SNat m -> Vec (m + n) a -> (Vec m a, Vec n a)'
69 template: ~ARG[1]
70 workInfo: Never
71 - BlackBox:
72 name: Clash.Sized.Vector.unconcat
73 kind: Expression
74 type: |-
75 unconcat :: KnownNat n -- ARG[0]
76 => SNat m -- ARG[1]
77 -> Vec (n * m) a -- ARG[2]
78 -> Vec n (Vec m a)
79 template: ~ARG[2]~DEVNULL[~ARG[0]]~DEVNULL[~ARG[1]]
80 workInfo: Never
81 - BlackBox:
82 name: Clash.Sized.Vector.map
83 kind: Declaration
84 type: 'map :: (a -> b) -> Vec n a -> Vec n b'
85 template: |-
86 // map begin
87 genvar ~GENSYM[i][1];
88 ~GENERATE
89 for (~SYM[1]=0; ~SYM[1] < ~LENGTH[~TYPO]; ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[map][2]~IF~SIZE[~TYP[1]]~THEN
90 wire ~TYPEL[~TYP[1]] ~GENSYM[map_in][3];
91 assign ~SYM[3] = ~VAR[vec][1][~SYM[1]*~SIZE[~TYPEL[~TYP[1]]]+:~SIZE[~TYPEL[~TYP[1]]]];~ELSE ~FI
92 ~OUTPUTUSAGE[0] ~TYPEL[~TYPO] ~GENSYM[map_out][4];
93 ~INST 0
94 ~OUTPUT <= ~SYM[4]~ ~TYPEL[~TYPO]~
95 ~INPUT <= ~SYM[3]~ ~TYPEL[~TYP[1]]~
96 ~INST
97 assign ~RESULT[~SYM[1]*~SIZE[~TYPEL[~TYPO]]+:~SIZE[~TYPEL[~TYPO]]] = ~SYM[4];
98 end
99 ~ENDGENERATE
100 // map end
101 workInfo: Identity 1 [0]
102 - BlackBox:
103 name: Clash.Sized.Vector.imap
104 kind: Declaration
105 type: 'imap :: KnownNat n => (Index n -> a -> b) -> Vec n a -> Vec n b'
106 template: |-
107 // imap begin
108 genvar ~GENSYM[i][1];
109 ~GENERATE
110 for (~SYM[1]=0; ~SYM[1] < ~LENGTH[~TYPO]; ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[imap][2]
111 wire [~SIZE[~INDEXTYPE[~LIT[0]]]-1:0] ~GENSYM[map_index][3];~IF~SIZE[~TYP[2]]~THEN
112 wire ~TYPEL[~TYP[2]] ~GENSYM[map_in][4];
113 assign ~SYM[4] = ~VAR[vec][2][~SYM[1]*~SIZE[~TYPEL[~TYP[2]]]+:~SIZE[~TYPEL[~TYP[2]]]];~ELSE ~FI
114 ~OUTPUTUSAGE[1] ~TYPEL[~TYPO] ~GENSYM[map_out][5];
115
116 assign ~SYM[3] = ~SIZE[~INDEXTYPE[~LIT[0]]]'d~MAXINDEX[~TYPO] - ~SYM[1][0+:~SIZE[~INDEXTYPE[~LIT[0]]]];
117 ~INST 1
118 ~OUTPUT <= ~SYM[5]~ ~TYPEL[~TYPO]~
119 ~INPUT <= ~SYM[3]~ ~INDEXTYPE[~LIT[0]]~
120 ~INPUT <= ~SYM[4]~ ~TYPEL[~TYP[2]]~
121 ~INST
122 assign ~RESULT[~SYM[1]*~SIZE[~TYPEL[~TYPO]]+:~SIZE[~TYPEL[~TYPO]]] = ~SYM[5];
123 end
124 ~ENDGENERATE
125 // imap end
126 workInfo: Never
127 - BlackBox:
128 name: Clash.Sized.Vector.imap_go
129 kind: Declaration
130 type: 'imap_go :: (Index n -> a -> b) -> Vec m a -> Index n -> Vec m b'
131 template: |-
132 // imap begin
133 genvar ~GENSYM[i][1];
134 ~GENERATE
135 for (~SYM[1]=0; ~SYM[1] < ~LENGTH[~TYPO]; ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[imap][2]
136 wire ~TYP[2] ~GENSYM[map_index][3];~IF~SIZE[~TYP[1]]~THEN
137 wire ~TYPEL[~TYP[1]] ~GENSYM[map_in][4];
138 assign ~SYM[4] = ~VAR[vec][1][~SYM[1]*~SIZE[~TYPEL[~TYP[1]]]+:~SIZE[~TYPEL[~TYP[1]]]];~ELSE ~FI
139 ~OUTPUTUSAGE[0] ~TYPEL[~TYPO] ~GENSYM[map_out][5];
140
141 assign ~SYM[3] = ~SIZE[~TYP[2]]'d~MAXINDEX[~TYPO] - ~SYM[1][0+:~SIZE[~TYP[2]]] + ~ARG[2];
142 ~INST 0
143 ~OUTPUT <= ~SYM[5]~ ~TYPEL[~TYPO]~
144 ~INPUT <= ~SYM[3]~ ~TYP[2]~
145 ~INPUT <= ~SYM[4]~ ~TYPEL[~TYP[1]]~
146 ~INST
147 assign ~RESULT[~SYM[1]*~SIZE[~TYPEL[~TYPO]]+:~SIZE[~TYPEL[~TYPO]]] = ~SYM[5];
148 end
149 ~ENDGENERATE
150 // imap end
151 workInfo: Never
152 - BlackBox:
153 name: Clash.Sized.Vector.zipWith
154 kind: Declaration
155 type: 'zipWith :: (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c'
156 template: |-
157 // zipWith start
158 genvar ~GENSYM[i][2];
159 ~GENERATE
160 for (~SYM[2] = 0; ~SYM[2] < ~LENGTH[~TYPO]; ~SYM[2] = ~SYM[2] + 1) begin : ~GENSYM[zipWith][6]~IF~SIZE[~TYP[1]]~THEN
161 wire ~TYPEL[~TYP[1]] ~GENSYM[zipWith_in1][3];
162 assign ~SYM[3] = ~VAR[vec1][1][~SYM[2]*~SIZE[~TYPEL[~TYP[1]]]+:~SIZE[~TYPEL[~TYP[1]]]];~ELSE ~FI~IF~SIZE[~TYP[2]]~THEN
163 wire ~TYPEL[~TYP[2]] ~GENSYM[zipWith_in2][4];
164 assign ~SYM[4] = ~VAR[vec2][2][~SYM[2]*~SIZE[~TYPEL[~TYP[2]]]+:~SIZE[~TYPEL[~TYP[2]]]];~ELSE ~FI
165 ~OUTPUTUSAGE[0] ~TYPEL[~TYPO] ~SYM[5];
166 ~INST 0
167 ~OUTPUT <= ~SYM[5]~ ~TYPEL[~TYPO]~
168 ~INPUT <= ~SYM[3]~ ~TYPEL[~TYP[1]]~
169 ~INPUT <= ~SYM[4]~ ~TYPEL[~TYP[2]]~
170 ~INST
171 assign ~RESULT[~SYM[2]*~SIZE[~TYPEL[~TYPO]]+:~SIZE[~TYPEL[~TYPO]]] = ~SYM[5];
172 end
173 ~ENDGENERATE
174 // zipWith end
175 workInfo: Never
176 - BlackBox:
177 name: Clash.Sized.Vector.foldr
178 kind: Declaration
179 type: 'foldr :: (a -> b -> b) -> b -> Vec n a -> b'
180 template: |-
181 // foldr start~IF ~LENGTH[~TYP[2]] ~THEN
182 wire ~TYPO ~GENSYM[intermediate][0] [0:~LENGTH[~TYP[2]]];
183 assign ~SYM[0][~LENGTH[~TYP[2]]] = ~ARG[1];
184
185 genvar ~GENSYM[i][3];
186 ~GENERATE
187 for (~SYM[3]=0; ~SYM[3] < ~LENGTH[~TYP[2]]; ~SYM[3]=~SYM[3]+1) begin : ~GENSYM[foldr][4]~IF~SIZE[~TYP[2]]~THEN
188 wire ~TYPEL[~TYP[2]] ~GENSYM[foldr_in1][5];
189 assign ~SYM[5] = ~VAR[xs][2][(~LENGTH[~TYP[2]]-1-~SYM[3])*~SIZE[~TYPEL[~TYP[2]]]+:~SIZE[~TYPEL[~TYP[2]]]];~ELSE ~FI
190 wire ~TYPO ~GENSYM[foldr_in2][6];
191 ~OUTPUTUSAGE[0] ~TYPO ~GENSYM[foldr_out][7];
192
193 assign ~SYM[6] = ~SYM[0][~SYM[3]+1];
194 ~INST 0
195 ~OUTPUT <= ~SYM[7]~ ~TYP[1]~
196 ~INPUT <= ~SYM[5]~ ~TYPEL[~TYP[2]]~
197 ~INPUT <= ~SYM[6]~ ~TYP[1]~
198 ~INST
199 assign ~SYM[0][~SYM[3]] = ~SYM[7];
200 end
201 ~ENDGENERATE
202
203 assign ~RESULT = ~SYM[0][0];
204 ~ELSE
205 assign ~RESULT = ~ARG[1];
206 ~FI// foldr end
207 workInfo: Never
208 - BlackBoxHaskell:
209 name: Clash.Sized.Vector.index_int
210 templateFunction: Clash.Primitives.Sized.Vector.indexIntVerilog
211 - BlackBox:
212 name: Clash.Sized.Vector.replace_int
213 kind: Declaration
214 type: 'replace_int :: KnownNat n => Vec n a -> Int -> a -> Vec n a'
215 template: |-
216 // vector replace begin
217 genvar ~GENSYM[i][0];
218 ~GENERATE
219 for (~SYM[0]=0;~SYM[0]<~LENGTH[~TYPO];~SYM[0]=~SYM[0]+1) begin : ~GENSYM[vector_replace][1]
220 assign ~RESULT[(~MAXINDEX[~TYPO]-~SYM[0])*~SIZE[~TYP[3]]+:~SIZE[~TYP[3]]] = ~ARG[2] == ~SYM[0] ? ~ARG[3] : ~VAR[vec][1][(~MAXINDEX[~TYPO]-~SYM[0])*~SIZE[~TYP[3]]+:~SIZE[~TYP[3]]];
221 end
222 ~ENDGENERATE
223 // vector replace end
224 - BlackBox:
225 name: Clash.Sized.Vector.maxIndex
226 kind: Expression
227 type: 'maxIndex :: KnownNat n => Vec n a -> Int'
228 template: ~SIZE[~TYPO]'sd~LIT[0] - ~SIZE[~TYPO]'d1
229 workInfo: Constant
230 - BlackBox:
231 name: Clash.Sized.Vector.length
232 kind: Expression
233 type: 'length :: KnownNat n => Vec n a -> Int'
234 template: ~SIZE[~TYPO]'sd~LIT[0]
235 workInfo: Constant
236 - BlackBox:
237 name: Clash.Sized.Vector.replicate
238 kind: Expression
239 type: 'replicate :: SNat n -> a -> Vec n a'
240 template: '{~LIT[0] {~ARG[1]}}'
241 workInfo: Never
242 - BlackBox:
243 name: Clash.Sized.Vector.transpose
244 kind: Declaration
245 type: 'transpose :: KnownNat n => Vec m (Vec n a) -> Vec n (Vec m a)'
246 template: |-
247 // transpose begin
248 genvar ~GENSYM[row_index][1];
249 genvar ~GENSYM[col_index][2];
250 ~GENERATE
251 for (~SYM[1] = 0; ~SYM[1] < ~LENGTH[~TYP[1]]; ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[transpose_outer][3]
252 for (~SYM[2] = 0; ~SYM[2] < ~LENGTH[~TYPO]; ~SYM[2] = ~SYM[2] + 1) begin : ~GENSYM[transpose_inner][4]
253 assign ~RESULT[((~SYM[2]*~SIZE[~TYPEL[~TYPO]])+(~SYM[1]*~SIZE[~TYPEL[~TYPEL[~TYPO]]]))+:~SIZE[~TYPEL[~TYPEL[~TYPO]]]] = ~VAR[matrix][1][((~SYM[1]*~SIZE[~TYPEL[~TYP[1]]])+(~SYM[2]*~SIZE[~TYPEL[~TYPEL[~TYPO]]]))+:~SIZE[~TYPEL[~TYPEL[~TYPO]]]];
254 end
255 end
256 ~ENDGENERATE
257 // transpose end
258 workInfo: Never
259 - BlackBox:
260 name: Clash.Sized.Vector.reverse
261 kind: Declaration
262 type: 'reverse :: Vec n a -> Vec n a'
263 template: |-
264 // reverse begin
265 genvar ~GENSYM[i][1];
266 ~GENERATE
267 for (~SYM[1] = 0; ~SYM[1] < ~LENGTH[~TYPO]; ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[reverse][2]
268 assign ~RESULT[(~LENGTH[~TYPO] - 1 - ~SYM[1])*~SIZE[~TYPEL[~TYPO]]+:~SIZE[~TYPEL[~TYPO]]] = ~VAR[vec][0][~SYM[1]*~SIZE[~TYPEL[~TYPO]]+:~SIZE[~TYPEL[~TYPO]]];
269 end
270 ~ENDGENERATE
271 // reverse end
272 workInfo: Never
273 - BlackBox:
274 name: Clash.Sized.Vector.concatBitVector#
275 kind: Expression
276 type: |-
277 concatBitVector# :: (KnownNat n, KnownNat m) -- (ARG[0],ARG[1])
278 => Vec n (BitVector m) -- ARG[2]
279 -> BitVector (n * m)
280 template: ~ARG[2]
281 workInfo: Never
282 - BlackBox:
283 name: Clash.Sized.Vector.unconcatBitVector#
284 kind: Expression
285 type: |-
286 unconcatBitVector# :: (KnownNat n, KnownNat m) -- (ARG[0],ARG[1])
287 => BitVector (n * m) -- ARG[2]
288 -> Vec n (BitVector m)
289 template: ~ARG[2]
290 workInfo: Never
291 - BlackBox:
292 name: Clash.Sized.Vector.rotateLeftS
293 kind: Declaration
294 type: 'rotateLeftS :: KnownNat n => Vec n a -> SNat d -> Vec n a'
295 template: |-
296 // rotateLeftS begin
297 localparam ~GENSYM[shift_amount][2] = ~LIT[2] % ~LIT[0];
298
299 ~GENERATE
300 if (~SYM[2] == 0) begin : ~GENSYM[no_shift][3]
301 assign ~RESULT = ~VAR[vec][1];
302 end else begin : ~GENSYM[do_shift][4]
303 assign ~RESULT = {~VAR[vec][1][((~LIT[0]-~SYM[2])*~SIZE[~TYPEL[~TYPO]])-1 : 0]
304 ,~VAR[vec][1][~SIZE[~TYPO]-1 : (~LIT[0]-~SYM[2])*~SIZE[~TYPEL[~TYPO]]]
305 };
306 end
307 ~ENDGENERATE
308 // rotateLeftS end
309 workInfo: Never
310 - BlackBox:
311 name: Clash.Sized.Vector.rotateRightS
312 kind: Declaration
313 type: 'rotateRightS :: KnownNat n => Vec n a -> SNat d -> Vec n a'
314 template: |-
315 // rotateRightS begin
316 localparam ~GENSYM[shift_amount][2] = ~LIT[2] % ~LIT[0];
317
318 ~GENERATE
319 if (~SYM[2] == 0) begin : ~GENSYM[no_shift][3]
320 assign ~RESULT = ~VAR[vec][1];
321 end else begin : ~GENSYM[do_shift][4]
322 assign ~RESULT = {~VAR[vec][1][(~SYM[2]*~SIZE[~TYPEL[~TYPO]])-1 : 0]
323 ,~VAR[vec][1][~SIZE[~TYPO]-1 : ~SYM[2]*~SIZE[~TYPEL[~TYPO]]]
324 };
325 end
326 ~ENDGENERATE
327 // rotateRightS end
328 workInfo: Never