Parent Directory | Revision Log
Revision 1.2 - (view) (download)
1 : | ia64p | 1.1 | .text |
2 : | .align 16 | ||
3 : | .global sad16_ia64# | ||
4 : | .proc sad16_ia64# | ||
5 : | sad16_ia64: | ||
6 : | |||
7 : | _LL=3 | ||
8 : | _SL=1 | ||
9 : | _OL=1 | ||
10 : | _PL=1 | ||
11 : | _AL=1 | ||
12 : | |||
13 : | alloc r9=ar.pfs,4,44,0,48 | ||
14 : | |||
15 : | mov r8 = r0 | ||
16 : | |||
17 : | mov r20 = ar.lc | ||
18 : | mov r21 = pr | ||
19 : | |||
20 : | dep.z r22 = r32, 3, 3 // erste 3 Bit mit 8 multiplizieren | ||
21 : | dep.z r23 = r33, 3, 3 // in r22 und r23 -> Schiebeflags | ||
22 : | |||
23 : | and r14 = -8, r32 // Parameter in untere Register kopieren | ||
24 : | and r15 = -8, r33 // Ref Cur mit 11111...1000 and-en | ||
25 : | mov r16 = r34 | ||
26 : | mov r17 = r35 | ||
27 : | ;; | ||
28 : | add r18 = 8, r14 // Adressenvorausberechnen | ||
29 : | add r19 = 8, r15 | ||
30 : | |||
31 : | sub r24 = 64, r22 // Schiftanzahl ausrechnen | ||
32 : | sub r25 = 64, r23 | ||
33 : | |||
34 : | add r26 = 16, r14 // Adressenvorausberechnen | ||
35 : | add r27 = 16, r15 | ||
36 : | |||
37 : | // Loop-counter initialisieren | ||
38 : | mov ar.lc = 15 // Loop 16 mal durchlaufen | ||
39 : | mov ar.ec = _LL + _SL + _OL + _PL + _AL + _AL // Die Loop am Schluss noch neun mal durchlaufen | ||
40 : | |||
41 : | // Rotating Predicate Register zuruecksetzen und P16 auf 1 | ||
42 : | mov pr.rot = 1 << 16 | ||
43 : | ;; | ||
44 : | |||
45 : | // Array-Konstrukte initialisieren | ||
46 : | .rotr _ald1[_LL+1], _ald2[_LL+1], _ald3[_LL+1], _ald4[_LL+1], _ald5[_LL+1], _ald6[_LL+1], _shru1[_SL+1], _shl1[_SL+1], _shru2[_SL], _shl2[_SL], _shru3[_SL], _shl3[_SL], _shru4[_SL], _shl4[_SL+1], _or1[_OL], _or2[_OL], _or3[_OL], _or4[_OL+1], _psadr1[_PL+1], _psadr2[_PL+1], _addr1[_AL+1] | ||
47 : | .rotp _aldp[_LL], _shp[_SL], _orp[_OL], _psadrp[_PL], _addrp1[_AL], _addrp2[_AL] | ||
48 : | |||
49 : | .L_loop_16: | ||
50 : | {.mmi | ||
51 : | (_aldp[0]) ld8 _ald1[0] = [r14], r16 // Cur Erste 8 Byte | ||
52 : | (_aldp[0]) ld8 _ald2[0] = [r18], r16 // Cur Zweite 8 Byte | ||
53 : | (_psadrp[0]) psad1 _psadr1[0] = _or2[0], _or4[0] // Psadden | ||
54 : | } | ||
55 : | {.mmi | ||
56 : | (_aldp[0]) ld8 _ald3[0] = [r26], r16 // Cur Dritte 8 Byte | ||
57 : | (_aldp[0]) ld8 _ald4[0] = [r15], r16 // Ref Erste 8 Byte | ||
58 : | (_psadrp[0]) psad1 _psadr2[0] = _or3[0], _or4[_OL] // _or2 +1 | ||
59 : | } | ||
60 : | {.mmi | ||
61 : | (_aldp[0]) ld8 _ald5[0] = [r19], r16 // Ref Zweite 8 Byte | ||
62 : | (_aldp[0]) ld8 _ald6[0] = [r27], r16 // Ref Dritte 8 Byte | ||
63 : | (_shp[0]) shr.u _shru1[0] = _ald1[_LL], r22 | ||
64 : | } | ||
65 : | {.mii | ||
66 : | (_orp[0]) or _or1[0] = _shl2[0], _shru3[0] // _shru2 + 1 und _shl2 + 1 | ||
67 : | (_shp[0]) shl _shl1[0] = _ald2[_LL], r24 | ||
68 : | (_shp[0]) shr.u _shru2[0] = _ald2[_LL], r22 | ||
69 : | } | ||
70 : | {.mii | ||
71 : | (_orp[0]) or _or2[0] = _shl3[0], _shru4[0] // _shru3 + 1 und _shl3 + 1 | ||
72 : | (_shp[0]) shl _shl2[0] = _ald3[_LL], r24 | ||
73 : | (_shp[0]) shr.u _shru3[0] = _ald4[_LL], r23 | ||
74 : | } | ||
75 : | {.mii | ||
76 : | (_orp[0]) or _or3[0] = _shl4[0], _shl4[_SL] //_shru4 + 1 und _shl4 + 1 | ||
77 : | (_shp[0]) shl _shl3[0] = _ald5[_LL], r25 | ||
78 : | (_shp[0]) shr.u _shru4[0] = _ald5[_LL], r23 | ||
79 : | } | ||
80 : | {.mmi | ||
81 : | (_orp[0]) or _or4[0] = _shru1[_SL], _shl1[_SL] | ||
82 : | (_shp[0]) shl _shl4[0]= _ald6[_LL], r25 | ||
83 : | } | ||
84 : | {.mmb | ||
85 : | (_addrp1[0]) add _addr1[0] = _psadr1[_PL], _psadr2[_PL] // Aufsummieren | ||
86 : | (_addrp2[0]) add r8 = r8, _addr1[_AL] | ||
87 : | br.ctop.sptk.few .L_loop_16 | ||
88 : | ;; | ||
89 : | } | ||
90 : | // Register zurueckschreiben | ||
91 : | mov ar.lc = r20 | ||
92 : | mov pr = r21,-1 | ||
93 : | br.ret.sptk.many rp | ||
94 : | .endp sad16_ia64# | ||
95 : | |||
96 : | |||
97 : | .align 16 | ||
98 : | .global sad8_ia64# | ||
99 : | .proc sad8_ia64# | ||
100 : | |||
101 : | sad8_ia64: | ||
102 : | |||
103 : | LL=3 | ||
104 : | SL=1 | ||
105 : | OL=1 | ||
106 : | PL=1 | ||
107 : | AL=1 | ||
108 : | |||
109 : | alloc r9=ar.pfs,3,29,0,32 | ||
110 : | mov r20 = ar.lc | ||
111 : | mov r21 = pr | ||
112 : | |||
113 : | dep.z r22 = r32, 3, 3 // erste 3 Bit mit 8 multiplizieren | ||
114 : | dep.z r23 = r33, 3, 3 // in r22 und r23 -> Schiebeflags | ||
115 : | |||
116 : | mov r8 = r0 // . . . . | ||
117 : | and r14 = -8, r32 // 0xFFFFFFFFFFFFFFF8, r32 | ||
118 : | and r15 = -8, r33 // 0xFFFFFFFFFFFFFFF8, r33 | ||
119 : | mov r16 = r34 | ||
120 : | // mov r17 = r35 | ||
121 : | ;; | ||
122 : | |||
123 : | add r18 = 8, r14 | ||
124 : | add r19 = 8, r15 | ||
125 : | |||
126 : | sub r24 = 64, r22 | ||
127 : | sub r25 = 64, r23 | ||
128 : | |||
129 : | // Loop-counter initialisieren | ||
130 : | mov ar.lc = 7 // Loop 7 mal durchlaufen | ||
131 : | mov ar.ec = LL + SL + OL + PL + AL // Die Loop am Schluss noch zehn mal durchlaufen | ||
132 : | |||
133 : | // Rotating Predicate Register zuruecksetzen und P16 auf 1 | ||
134 : | mov pr.rot = 1 << 16 | ||
135 : | ;; | ||
136 : | .rotr ald1[LL+1], ald2[LL+1], ald3[LL+1], ald4[LL+1], shru1[SL+1], shl1[SL+1], shru2[SL+1], shl2[SL+1], or1[OL+1], or2[OL+1], psadr[PL+1], addr[AL+1] | ||
137 : | .rotp aldp[LL], shp[SL], orp[OL], psadrp[PL], addrp[AL] | ||
138 : | .L_loop_8: | ||
139 : | {.mmi | ||
140 : | (aldp[0]) ld8 ald1[0] = [r14], r16 // Cur laden | ||
141 : | (aldp[0]) ld8 ald2[0] = [r18], r16 | ||
142 : | (shp[0]) shr.u shru1[0] = ald1[LL], r22 // mergen | ||
143 : | } | ||
144 : | {.mii | ||
145 : | (orp[0]) or or1[0] = shru1[SL], shl1[SL] | ||
146 : | (shp[0]) shl shl1[0] = ald2[LL], r24 | ||
147 : | (shp[0]) shr.u shru2[0] = ald3[LL], r23 // mergen | ||
148 : | } | ||
149 : | {.mmi | ||
150 : | (aldp[0]) ld8 ald3[0] = [r15], r16 // Ref laden | ||
151 : | (aldp[0]) ld8 ald4[0] = [r19], r16 | ||
152 : | (shp[0]) shl shl2[0] = ald4[LL], r25 | ||
153 : | } | ||
154 : | {.mmi | ||
155 : | (orp[0]) or or2[0] = shru2[SL], shl2[SL] | ||
156 : | (addrp[0]) add r8 = r8, psadr[PL] | ||
157 : | (psadrp[0]) psad1 psadr[0] = or1[OL], or2[OL] | ||
158 : | } | ||
159 : | {.mbb | ||
160 : | br.ctop.sptk.few .L_loop_8 | ||
161 : | ;; | ||
162 : | } | ||
163 : | |||
164 : | mov ar.lc = r20 | ||
165 : | mov pr = r21,-1 | ||
166 : | br.ret.sptk.many b0 | ||
167 : | .endp sad8_ia64# | ||
168 : | |||
169 : | |||
170 : | .common sad16bi#,8,8 | ||
171 : | .align 16 | ||
172 : | .global sad16bi_ia64# | ||
173 : | .proc sad16bi_ia64# | ||
174 : | sad16bi_ia64: | ||
175 : | .prologue | ||
176 : | .save ar.lc, r2 | ||
177 : | mov r2 = ar.lc | ||
178 : | .body | ||
179 : | zxt4 r35 = r35 | ||
180 : | mov r8 = r0 | ||
181 : | mov r23 = r0 | ||
182 : | addl r22 = 255, r0 | ||
183 : | .L21: | ||
184 : | addl r14 = 7, r0 | ||
185 : | mov r19 = r32 | ||
186 : | mov r21 = r34 | ||
187 : | mov r20 = r33 | ||
188 : | ;; | ||
189 : | mov ar.lc = r14 | ||
190 : | ;; | ||
191 : | .L105: | ||
192 : | mov r17 = r20 | ||
193 : | mov r18 = r21 | ||
194 : | ;; | ||
195 : | ld1 r14 = [r17], 1 | ||
196 : | ld1 r15 = [r18], 1 | ||
197 : | ;; | ||
198 : | add r14 = r14, r15 | ||
199 : | ;; | ||
200 : | adds r14 = 1, r14 | ||
201 : | ;; | ||
202 : | shr.u r16 = r14, 1 | ||
203 : | ;; | ||
204 : | cmp4.le p6, p7 = r0, r16 | ||
205 : | ;; | ||
206 : | (p7) mov r16 = r0 | ||
207 : | (p7) br.cond.dpnt .L96 | ||
208 : | ;; | ||
209 : | cmp4.ge p6, p7 = r22, r16 | ||
210 : | ;; | ||
211 : | (p7) addl r16 = 255, r0 | ||
212 : | .L96: | ||
213 : | ld1 r14 = [r19] | ||
214 : | adds r20 = 2, r20 | ||
215 : | adds r21 = 2, r21 | ||
216 : | ;; | ||
217 : | sub r15 = r14, r16 | ||
218 : | ;; | ||
219 : | cmp4.ge p6, p7 = 0, r15 | ||
220 : | ;; | ||
221 : | (p6) sub r14 = r16, r14 | ||
222 : | (p7) add r8 = r8, r15 | ||
223 : | ;; | ||
224 : | (p6) add r8 = r8, r14 | ||
225 : | ld1 r15 = [r18] | ||
226 : | ld1 r14 = [r17] | ||
227 : | ;; | ||
228 : | add r14 = r14, r15 | ||
229 : | adds r17 = 1, r19 | ||
230 : | ;; | ||
231 : | adds r14 = 1, r14 | ||
232 : | ;; | ||
233 : | shr.u r16 = r14, 1 | ||
234 : | ;; | ||
235 : | cmp4.le p6, p7 = r0, r16 | ||
236 : | ;; | ||
237 : | (p7) mov r16 = r0 | ||
238 : | (p7) br.cond.dpnt .L102 | ||
239 : | ;; | ||
240 : | cmp4.ge p6, p7 = r22, r16 | ||
241 : | ;; | ||
242 : | (p7) addl r16 = 255, r0 | ||
243 : | .L102: | ||
244 : | ld1 r14 = [r17] | ||
245 : | adds r19 = 2, r19 | ||
246 : | ;; | ||
247 : | sub r15 = r14, r16 | ||
248 : | ;; | ||
249 : | cmp4.ge p6, p7 = 0, r15 | ||
250 : | ;; | ||
251 : | (p7) add r8 = r8, r15 | ||
252 : | (p6) sub r14 = r16, r14 | ||
253 : | ;; | ||
254 : | (p6) add r8 = r8, r14 | ||
255 : | br.cloop.sptk.few .L105 | ||
256 : | adds r23 = 1, r23 | ||
257 : | add r32 = r32, r35 | ||
258 : | add r33 = r33, r35 | ||
259 : | add r34 = r34, r35 | ||
260 : | ;; | ||
261 : | cmp4.geu p6, p7 = 15, r23 | ||
262 : | (p6) br.cond.dptk .L21 | ||
263 : | mov ar.lc = r2 | ||
264 : | br.ret.sptk.many b0 | ||
265 : | .endp sad16bi_ia64# | ||
266 : | |||
267 : | |||
268 : | ia64p | 1.2 | |
269 : | |||
270 : | |||
271 : | |||
272 : | |||
273 : | |||
274 : | .text | ||
275 : | ia64p | 1.1 | .align 16 |
276 : | .global dev16_ia64# | ||
277 : | .proc dev16_ia64# | ||
278 : | ia64p | 1.2 | .auto |
279 : | ia64p | 1.1 | dev16_ia64: |
280 : | ia64p | 1.2 | // renamings for better readability |
281 : | stride = r18 | ||
282 : | pfs = r19 //for saving previous function state | ||
283 : | cura0 = r20 //address of first 8-byte block of cur | ||
284 : | cura1 = r21 //address of second 8-byte block of cur | ||
285 : | mean0 = r22 //registers for calculating the sum in parallel | ||
286 : | mean1 = r23 | ||
287 : | mean2 = r24 | ||
288 : | mean3 = r25 | ||
289 : | dev0 = r26 //same for the deviation | ||
290 : | dev1 = r27 | ||
291 : | dev2 = r28 | ||
292 : | dev3 = r29 | ||
293 : | |||
294 : | ia64p | 1.1 | .body |
295 : | ia64p | 1.2 | alloc pfs = ar.pfs, 2, 38, 0, 40 |
296 : | |||
297 : | mov cura0 = in0 | ||
298 : | mov stride = in1 | ||
299 : | add cura1 = 8, cura0 | ||
300 : | |||
301 : | .rotr c[32], psad[8] // just using rotating registers to get an array ;-) | ||
302 : | |||
303 : | .explicit | ||
304 : | {.mmi | ||
305 : | ld8 c[0] = [cura0], stride // load them ... | ||
306 : | ld8 c[1] = [cura1], stride | ||
307 : | ;; | ||
308 : | } | ||
309 : | {.mmi | ||
310 : | ld8 c[2] = [cura0], stride | ||
311 : | ld8 c[3] = [cura1], stride | ||
312 : | ;; | ||
313 : | } | ||
314 : | {.mmi | ||
315 : | ld8 c[4] = [cura0], stride | ||
316 : | ld8 c[5] = [cura1], stride | ||
317 : | ;; | ||
318 : | } | ||
319 : | {.mmi | ||
320 : | ld8 c[6] = [cura0], stride | ||
321 : | ld8 c[7] = [cura1], stride | ||
322 : | ;; | ||
323 : | } | ||
324 : | {.mmi | ||
325 : | ld8 c[8] = [cura0], stride | ||
326 : | ld8 c[9] = [cura1], stride | ||
327 : | ;; | ||
328 : | } | ||
329 : | {.mmi | ||
330 : | ld8 c[10] = [cura0], stride | ||
331 : | ld8 c[11] = [cura1], stride | ||
332 : | ;; | ||
333 : | } | ||
334 : | {.mii | ||
335 : | ld8 c[12] = [cura0], stride | ||
336 : | psad1 mean0 = c[0], r0 // get the sum of them ... | ||
337 : | psad1 mean1 = c[1], r0 | ||
338 : | } | ||
339 : | {.mmi | ||
340 : | ld8 c[13] = [cura1], stride | ||
341 : | ;; | ||
342 : | ld8 c[14] = [cura0], stride | ||
343 : | psad1 mean2 = c[2], r0 | ||
344 : | } | ||
345 : | {.mii | ||
346 : | ld8 c[15] = [cura1], stride | ||
347 : | psad1 mean3 = c[3], r0 | ||
348 : | ;; | ||
349 : | psad1 psad[0] = c[4], r0 | ||
350 : | } | ||
351 : | {.mmi | ||
352 : | ld8 c[16] = [cura0], stride | ||
353 : | ld8 c[17] = [cura1], stride | ||
354 : | psad1 psad[1] = c[5], r0 | ||
355 : | ;; | ||
356 : | } | ||
357 : | {.mii | ||
358 : | ld8 c[18] = [cura0], stride | ||
359 : | psad1 psad[2] = c[6], r0 | ||
360 : | psad1 psad[3] = c[7], r0 | ||
361 : | } | ||
362 : | {.mmi | ||
363 : | ld8 c[19] = [cura1], stride | ||
364 : | ;; | ||
365 : | ld8 c[20] = [cura0], stride | ||
366 : | psad1 psad[4] = c[8], r0 | ||
367 : | } | ||
368 : | {.mii | ||
369 : | ld8 c[21] = [cura1], stride | ||
370 : | psad1 psad[5] = c[9], r0 | ||
371 : | ;; | ||
372 : | add mean0 = mean0, psad[0] | ||
373 : | } | ||
374 : | {.mmi | ||
375 : | ld8 c[22] = [cura0], stride | ||
376 : | ld8 c[23] = [cura1], stride | ||
377 : | add mean1 = mean1, psad[1] | ||
378 : | ;; | ||
379 : | } | ||
380 : | {.mii | ||
381 : | ld8 c[24] = [cura0], stride | ||
382 : | psad1 psad[0] = c[10], r0 | ||
383 : | psad1 psad[1] = c[11], r0 | ||
384 : | } | ||
385 : | {.mmi | ||
386 : | ld8 c[25] = [cura1], stride | ||
387 : | ;; | ||
388 : | ld8 c[26] = [cura0], stride | ||
389 : | add mean2 = mean2, psad[2] | ||
390 : | } | ||
391 : | {.mii | ||
392 : | ld8 c[27] = [cura1], stride | ||
393 : | add mean3 = mean3, psad[3] | ||
394 : | ;; | ||
395 : | psad1 psad[2] = c[12], r0 | ||
396 : | } | ||
397 : | {.mmi | ||
398 : | ld8 c[28] = [cura0], stride | ||
399 : | ld8 c[29] = [cura1], stride | ||
400 : | psad1 psad[3] = c[13], r0 | ||
401 : | ;; | ||
402 : | } | ||
403 : | {.mii | ||
404 : | ld8 c[30] = [cura0] | ||
405 : | psad1 psad[6] = c[14], r0 | ||
406 : | psad1 psad[7] = c[15], r0 | ||
407 : | } | ||
408 : | {.mmi | ||
409 : | ld8 c[31] = [cura1] | ||
410 : | ;; | ||
411 : | add mean0 = mean0, psad[0] | ||
412 : | add mean1 = mean1, psad[1] | ||
413 : | } | ||
414 : | {.mii | ||
415 : | add mean2 = mean2, psad[4] | ||
416 : | add mean3 = mean3, psad[5] | ||
417 : | ;; | ||
418 : | psad1 psad[0] = c[16], r0 | ||
419 : | } | ||
420 : | {.mmi | ||
421 : | add mean0 = mean0, psad[2] | ||
422 : | add mean1 = mean1, psad[3] | ||
423 : | psad1 psad[1] = c[17], r0 | ||
424 : | ;; | ||
425 : | } | ||
426 : | {.mii | ||
427 : | add mean2 = mean2, psad[6] | ||
428 : | psad1 psad[2] = c[18], r0 | ||
429 : | psad1 psad[3] = c[19], r0 | ||
430 : | } | ||
431 : | {.mmi | ||
432 : | add mean3 = mean3, psad[7] | ||
433 : | ;; | ||
434 : | add mean0 = mean0, psad[0] | ||
435 : | psad1 psad[4] = c[20], r0 | ||
436 : | } | ||
437 : | {.mii | ||
438 : | add mean1 = mean1, psad[1] | ||
439 : | psad1 psad[5] = c[21], r0 | ||
440 : | ;; | ||
441 : | psad1 psad[6] = c[22], r0 | ||
442 : | } | ||
443 : | {.mmi | ||
444 : | add mean2 = mean2, psad[2] | ||
445 : | add mean3 = mean3, psad[3] | ||
446 : | psad1 psad[7] = c[23], r0 | ||
447 : | ;; | ||
448 : | } | ||
449 : | {.mii | ||
450 : | add mean0 = mean0, psad[4] | ||
451 : | psad1 psad[0] = c[24], r0 | ||
452 : | psad1 psad[1] = c[25], r0 | ||
453 : | } | ||
454 : | {.mmi | ||
455 : | add mean1 = mean1, psad[5] | ||
456 : | ;; | ||
457 : | add mean2 = mean2, psad[6] | ||
458 : | psad1 psad[2] = c[26], r0 | ||
459 : | } | ||
460 : | {.mii | ||
461 : | add mean3 = mean3, psad[7] | ||
462 : | psad1 psad[3] = c[27], r0 | ||
463 : | ;; | ||
464 : | psad1 psad[4] = c[28], r0 | ||
465 : | } | ||
466 : | {.mmi | ||
467 : | add mean0 = mean0, psad[0] | ||
468 : | add mean1 = mean1, psad[1] | ||
469 : | psad1 psad[5] = c[29], r0 | ||
470 : | ;; | ||
471 : | } | ||
472 : | {.mii | ||
473 : | add mean2 = mean2, psad[2] | ||
474 : | psad1 psad[6] = c[30], r0 | ||
475 : | psad1 psad[7] = c[31], r0 | ||
476 : | } | ||
477 : | {.mmi | ||
478 : | add mean3 = mean3, psad[3] | ||
479 : | ;; | ||
480 : | add mean0 = mean0, psad[4] | ||
481 : | add mean1 = mean1, psad[5] | ||
482 : | } | ||
483 : | {.mbb | ||
484 : | add mean2 = mean2, mean3 | ||
485 : | nop.b 1 | ||
486 : | nop.b 1 | ||
487 : | ;; | ||
488 : | } | ||
489 : | {.mib | ||
490 : | add mean0 = mean0, psad[6] | ||
491 : | add mean1 = mean1, psad[7] | ||
492 : | nop.b 1 | ||
493 : | ;; | ||
494 : | } | ||
495 : | {.mib | ||
496 : | add mean0 = mean0, mean1 | ||
497 : | // add mean2 = 127, mean2 // this could make our division more exact, but does not help much | ||
498 : | ;; | ||
499 : | } | ||
500 : | {.mib | ||
501 : | add mean0 = mean0, mean2 | ||
502 : | ;; | ||
503 : | } | ||
504 : | |||
505 : | {.mib | ||
506 : | shr.u mean0 = mean0, 8 // divide them ... | ||
507 : | ;; | ||
508 : | } | ||
509 : | {.mib | ||
510 : | mux1 mean0 = mean0, @brcst | ||
511 : | ;; | ||
512 : | } | ||
513 : | {.mii | ||
514 : | nop.m 0 | ||
515 : | psad1 dev0 = c[0], mean0 // and do a sad again ... | ||
516 : | psad1 dev1 = c[1], mean0 | ||
517 : | } | ||
518 : | {.mii | ||
519 : | nop.m 0 | ||
520 : | psad1 dev2 = c[2], mean0 | ||
521 : | psad1 dev3 = c[3], mean0 | ||
522 : | } | ||
523 : | {.mii | ||
524 : | nop.m 0 | ||
525 : | psad1 psad[0] = c[4], mean0 | ||
526 : | psad1 psad[1] = c[5], mean0 | ||
527 : | } | ||
528 : | {.mii | ||
529 : | nop.m 0 | ||
530 : | psad1 psad[2] = c[6], mean0 | ||
531 : | psad1 psad[3] = c[7], mean0 | ||
532 : | } | ||
533 : | {.mii | ||
534 : | nop.m 0 | ||
535 : | psad1 psad[4] = c[8], mean0 | ||
536 : | psad1 psad[5] = c[9], mean0 | ||
537 : | ;; | ||
538 : | } | ||
539 : | {.mii | ||
540 : | add dev0 = dev0, psad[0] | ||
541 : | psad1 psad[6] = c[10], mean0 | ||
542 : | psad1 psad[7] = c[11], mean0 | ||
543 : | } | ||
544 : | {.mmi | ||
545 : | add dev1 = dev1, psad[1] | ||
546 : | |||
547 : | add dev2 = dev2, psad[2] | ||
548 : | psad1 psad[0] = c[12], mean0 | ||
549 : | } | ||
550 : | {.mii | ||
551 : | add dev3 = dev3, psad[3] | ||
552 : | psad1 psad[1] = c[13], mean0 | ||
553 : | ;; | ||
554 : | psad1 psad[2] = c[14], mean0 | ||
555 : | } | ||
556 : | {.mmi | ||
557 : | add dev0 = dev0, psad[4] | ||
558 : | add dev1 = dev1, psad[5] | ||
559 : | psad1 psad[3] = c[15], mean0 | ||
560 : | } | ||
561 : | {.mii | ||
562 : | add dev2 = dev2, psad[6] | ||
563 : | psad1 psad[4] = c[16], mean0 | ||
564 : | psad1 psad[5] = c[17], mean0 | ||
565 : | } | ||
566 : | {.mmi | ||
567 : | add dev3 = dev3, psad[7] | ||
568 : | ;; | ||
569 : | add dev0 = dev0, psad[0] | ||
570 : | psad1 psad[6] = c[18], mean0 | ||
571 : | } | ||
572 : | {.mii | ||
573 : | add dev1 = dev1, psad[1] | ||
574 : | psad1 psad[7] = c[19], mean0 | ||
575 : | |||
576 : | psad1 psad[0] = c[20], mean0 | ||
577 : | } | ||
578 : | {.mmi | ||
579 : | add dev2 = dev2, psad[2] | ||
580 : | add dev3 = dev3, psad[3] | ||
581 : | psad1 psad[1] = c[21], mean0 | ||
582 : | ;; | ||
583 : | } | ||
584 : | {.mii | ||
585 : | add dev0 = dev0, psad[4] | ||
586 : | psad1 psad[2] = c[22], mean0 | ||
587 : | psad1 psad[3] = c[23], mean0 | ||
588 : | } | ||
589 : | {.mmi | ||
590 : | add dev1 = dev1, psad[5] | ||
591 : | |||
592 : | add dev2 = dev2, psad[6] | ||
593 : | psad1 psad[4] = c[24], mean0 | ||
594 : | } | ||
595 : | {.mii | ||
596 : | add dev3 = dev3, psad[7] | ||
597 : | psad1 psad[5] = c[25], mean0 | ||
598 : | ;; | ||
599 : | psad1 psad[6] = c[26], mean0 | ||
600 : | } | ||
601 : | {.mmi | ||
602 : | add dev0 = dev0, psad[0] | ||
603 : | add dev1 = dev1, psad[1] | ||
604 : | psad1 psad[7] = c[27], mean0 | ||
605 : | } | ||
606 : | {.mii | ||
607 : | add dev2 = dev2, psad[2] | ||
608 : | psad1 psad[0] = c[28], mean0 | ||
609 : | psad1 psad[1] = c[29], mean0 | ||
610 : | } | ||
611 : | {.mmi | ||
612 : | add dev3 = dev3, psad[3] | ||
613 : | ;; | ||
614 : | add dev0 = dev0, psad[4] | ||
615 : | psad1 psad[2] = c[30], mean0 | ||
616 : | } | ||
617 : | {.mii | ||
618 : | add dev1 = dev1, psad[5] | ||
619 : | psad1 psad[3] = c[31], mean0 | ||
620 : | ;; | ||
621 : | add dev2 = dev2, psad[6] | ||
622 : | } | ||
623 : | {.mmi | ||
624 : | add dev3 = dev3, psad[7] | ||
625 : | add dev0 = dev0, psad[0] | ||
626 : | add dev1 = dev1, psad[1] | ||
627 : | ;; | ||
628 : | } | ||
629 : | {.mii | ||
630 : | add dev2 = dev2, psad[2] | ||
631 : | add dev3 = dev3, psad[3] | ||
632 : | add ret0 = dev0, dev1 | ||
633 : | ;; | ||
634 : | } | ||
635 : | {.mib | ||
636 : | add dev2 = dev2, dev3 | ||
637 : | nop.i 1 | ||
638 : | nop.b 1 | ||
639 : | ;; | ||
640 : | } | ||
641 : | {.mib | ||
642 : | add ret0 = ret0, dev2 | ||
643 : | nop.i 1 | ||
644 : | ia64p | 1.1 | br.ret.sptk.many b0 |
645 : | ia64p | 1.2 | } |
646 : | ia64p | 1.1 | .endp dev16_ia64# |
No admin address has been configured | ViewVC Help |
Powered by ViewVC 1.0.4 |