| 23 |
// * |
// * |
| 24 |
// ------------------------------------------------------------------------------ |
// ------------------------------------------------------------------------------ |
| 25 |
|
|
|
.text |
|
|
|
|
|
// ------------------------------------------------------------------------------ |
|
|
// * SAD16_IA64 |
|
|
// * |
|
|
// * In: |
|
|
// * r32 = cur (aligned) |
|
|
// * r33 = ref (not aligned) |
|
|
// * r34 = stride |
|
|
// * r35 = bestsad |
|
|
// * Out: |
|
|
// * r8 = sum of absolute differences |
|
|
// * |
|
|
// ------------------------------------------------------------------------------ |
|
|
|
|
|
.align 16 |
|
|
.global sad16_ia64# |
|
|
.proc sad16_ia64# |
|
|
sad16_ia64: |
|
|
|
|
|
|
|
|
// Define Latencies |
|
|
LL16=3 // load latency |
|
|
SL16=1 // shift latency |
|
|
OL16=1 // or latency |
|
|
PL16=1 // psad latency |
|
|
AL16=1 // add latency |
|
|
|
|
|
// Allocate Registern in RSE |
|
|
alloc r9=ar.pfs,4,36,0,40 |
|
|
|
|
|
// lfetch [r32] // might help |
|
|
|
|
|
mov r8 = r0 // clear the return reg |
|
|
|
|
|
// Save LC and predicates |
|
|
mov r20 = ar.lc |
|
|
mov r21 = pr |
|
|
|
|
|
dep.z r23 = r33, 3, 3 // get the # of bits ref is misaligned |
|
|
and r15 = -8, r33 // align the ref pointer by deleting the last 3 bit |
|
|
|
|
|
mov r14 = r32 // save the cur pointer |
|
|
mov r16 = r34 // save stride |
|
|
mov r17 = r35 // save bestsad |
|
|
|
|
|
;; |
|
|
add r18 = 8, r14 // precalc second cur pointer |
|
|
add r19 = 8, r15 // precalc second ref pointer |
|
|
add r27 = 16, r15 // precalc third ref pointer |
|
|
sub r25 = 64, r23 // # of right shifts |
|
|
|
|
|
// Initialize Loop-counters |
|
|
mov ar.lc = 15 // loop 16 times |
|
|
mov ar.ec = LL16 + SL16 + OL16 + PL16 + AL16 + AL16 |
|
|
mov pr.rot = 1 << 16 // reseting rotating predicate regs and set p16 to 1 |
|
|
;; |
|
|
|
|
|
// Intialize Arrays for Register Rotation |
|
|
.rotr r_cur_ld1[LL16+SL16+OL16+1], r_cur_ld2[LL16+SL16+OL16+1], r_ref_16_ld1[LL16+1], r_ref_16_ld2[LL16+1], r_ref_16_ld3[LL16+1], r_ref_16_shru1[SL16], r_ref_16_shl1[SL16], r_ref_16_shru2[SL16], r_ref_16_shl2[SL16+1], r_ref_16_or1[OL16], r_ref_16_or2[OL16+1], r_psad1[PL16+1], r_psad2[PL16+1], r_add_16[AL16+1] |
|
|
.rotp p_ld_16[LL16], p_sh_16[SL16], p_or_16[OL16], p_psad_16[PL16], p_add1_16[AL16], p_add2_16[AL16] |
|
| 26 |
|
|
|
.L_loop16: |
|
|
{.mmi |
|
|
(p_ld_16[0]) ld8 r_cur_ld1[0] = [r14], r16 // Cur load first 8 Byte |
|
|
(p_ld_16[0]) ld8 r_cur_ld2[0] = [r18], r16 // Cur load next 8 Byte |
|
|
(p_psad_16[0]) psad1 r_psad1[0] = r_cur_ld1[LL16+SL16+OL16], r_ref_16_or2[0] // psad of cur and ref |
|
|
} |
|
|
{.mmi |
|
|
(p_ld_16[0]) ld8 r_ref_16_ld1[0] = [r15], r16 // Ref load first 8 Byte (unaligned) |
|
|
(p_ld_16[0]) ld8 r_ref_16_ld2[0] = [r19], r16 // Ref load next 8 Byte (unaligned) |
|
|
(p_psad_16[0]) psad1 r_psad2[0] = r_cur_ld2[LL16+SL16+OL16], r_ref_16_or2[OL16] // psad of cur_2 and ref_2 |
|
|
} |
|
|
{.mii |
|
|
(p_ld_16[0]) ld8 r_ref_16_ld3[0] = [r27], r16 // Ref load third 8 Byte (unaligned) |
|
|
(p_or_16[0]) or r_ref_16_or1[0] = r_ref_16_shl1[0], r_ref_16_shru2[0] // Ref or r_ref_16_shl1 + 1 and r_ref_16_shl1 + 1 |
|
|
(p_sh_16[0]) shr.u r_ref_16_shru1[0] = r_ref_16_ld1[LL16], r23 // Ref shift |
|
|
} |
|
|
{.mii |
|
|
(p_or_16[0]) or r_ref_16_or2[0] = r_ref_16_shl2[0], r_ref_16_shl2[SL16] // Ref or r_ref_shru2 + 1 and r_ref_shl2 + 1 |
|
|
(p_sh_16[0]) shl r_ref_16_shl1[0] = r_ref_16_ld2[LL16], r25 // Ref shift |
|
|
(p_sh_16[0]) shr.u r_ref_16_shru2[0] = r_ref_16_ld2[LL16], r23 // Ref shift |
|
|
} |
|
|
{.mib |
|
|
(p_add2_16[0]) cmp.ge.unc p6, p7 = r8, r17 |
|
|
(p_sh_16[0]) shl r_ref_16_shl2[0]= r_ref_16_ld3[LL16], r25 // Ref shift |
|
|
(p6) br.spnt.few .L_loop_exit16 |
|
|
} |
|
|
{.mmb |
|
|
(p_add1_16[0]) add r_add_16[0] = r_psad1[PL16], r_psad2[PL16] // add the psad results |
|
|
(p_add2_16[0]) add r8 = r8, r_add_16[AL16] // add the results to the sum |
|
|
br.ctop.sptk.few .L_loop16 |
|
|
;; |
|
|
} |
|
|
.L_loop_exit16: |
|
|
|
|
|
// Restore LC and predicates |
|
|
mov ar.lc = r20 |
|
|
mov pr = r21,-1 |
|
|
|
|
|
// Return |
|
|
br.ret.sptk.many rp |
|
|
.endp sad16_ia64# |
|
|
|
|
|
// ------------------------------------------------------------------------------ |
|
|
// * SAD8_IA64 |
|
|
// * |
|
|
// * In: |
|
|
// * r32 = cur (aligned) |
|
|
// * r33 = ref (not aligned) |
|
|
// * r34 = stride |
|
|
// * Out: |
|
|
// * r8 = sum of absolute differences |
|
|
// * |
|
|
// ------------------------------------------------------------------------------ |
|
|
|
|
|
.align 16 |
|
|
.global sad8_ia64# |
|
|
.proc sad8_ia64# |
|
|
|
|
|
sad8_ia64: |
|
|
|
|
|
|
|
|
// Define Latencies |
|
|
LL8=3 // load latency |
|
|
SL8=1 // shift latency |
|
|
OL8=1 // or latency |
|
|
PL8=1 // psad latency |
|
|
AL8=1 // add latency |
|
|
|
|
|
// Allocate Registers in RSE |
|
|
alloc r9 = ar.pfs,3,21,0,24 |
|
|
|
|
|
// lfetch [r32] // Maybe this helps? |
|
|
|
|
|
mov r8 = r0 // Initialize result |
|
|
|
|
|
mov r14 = r32 // Save Cur |
|
|
and r15 = -8, r33 // Align the Ref pointer by deleting the last 3 bit |
|
|
mov r16 = r34 // Save Stride |
|
|
|
|
|
// Save LC and predicates |
|
|
mov r20 = ar.lc |
|
|
mov r21 = pr |
|
|
|
|
|
dep.z r23 = r33, 3, 3 // get the # of bits ref is misaligned |
|
|
|
|
|
;; |
|
|
|
|
|
add r19 = 8, r15 // Precalculate second load-offset |
|
|
sub r25 = 64, r23 // Precalculate # of shifts |
|
|
|
|
|
// Initialize Loop-Counters |
|
|
mov ar.lc = 7 // Loop 7 times |
|
|
mov ar.ec = LL8 + SL8 + OL8 + PL8 + AL8 // Epiloque |
|
|
mov pr.rot = 1 << 16 // Reset Predicate Registers and initialize with P16 |
|
|
|
|
|
// Initalize Arrays for Register Rotation |
|
|
.rotr r_cur_ld[LL8+SL8+OL8+1], r_ref_ld1[LL8+1], r_ref_ld2[LL8+1], r_shru[SL8+1], r_shl[SL8+1], r_or[OL8+1], r_psad[PL8+1] |
|
|
.rotp p_ld[LL8], p_sh[SL8], p_or[OL8], p_psad[PL8], p_add[AL8] |
|
|
|
|
|
;; |
|
|
.L_loop8: |
|
|
// {.mmi |
|
|
(p_ld[0]) ld8 r_ref_ld1[0] = [r15], r16 // Load 1st 8Byte from Ref |
|
|
(p_ld[0]) ld8 r_cur_ld[0] = [r14], r16 // Load Cur |
|
|
(p_psad[0]) psad1 r_psad[0] = r_cur_ld[LL8+SL8+OL8], r_or[OL8] // Do the Calculation |
|
|
// } |
|
|
// {.mii |
|
|
(p_ld[0]) ld8 r_ref_ld2[0] = [r19], r16 // Load 2nd 8Byte from Ref |
|
|
(p_sh[0]) shr.u r_shru[0] = r_ref_ld1[LL8], r23 // Shift unaligned Ref parts |
|
|
(p_sh[0]) shl r_shl[0] = r_ref_ld2[LL8], r25 // Shift unaligned Ref parts |
|
|
// } |
|
|
// {.mib |
|
|
(p_or[0]) or r_or[0] = r_shru[SL8], r_shl[SL8] // Combine unaligned Ref parts |
|
|
(p_add[0]) add r8 = r8, r_psad[PL8] // Sum psad result |
|
|
br.ctop.sptk.few .L_loop8 |
|
|
;; |
|
|
// } |
|
|
|
|
|
// Restore Loop counters |
|
|
mov ar.lc = r20 |
|
|
mov pr = r21,-1 |
|
|
|
|
|
// Return |
|
|
br.ret.sptk.many b0 |
|
|
.endp sad8_ia64# |
|
| 27 |
|
|
| 28 |
|
|
| 29 |
.common sad16bi#,8,8 |
.common sad16bi#,8,8 |
| 503 |
br.ret.sptk.many b0 |
br.ret.sptk.many b0 |
| 504 |
} |
} |
| 505 |
.endp dev16_ia64# |
.endp dev16_ia64# |
| 506 |
|
|
| 507 |
|
|
| 508 |
|
// ########################################################### |
| 509 |
|
// ########################################################### |
| 510 |
|
// Neue version von gruppe 01 ################################ |
| 511 |
|
// ########################################################### |
| 512 |
|
// ########################################################### |
| 513 |
|
|
| 514 |
|
|
| 515 |
|
|
| 516 |
|
.text |
| 517 |
|
.align 16 |
| 518 |
|
.global sad16_ia64# |
| 519 |
|
.proc sad16_ia64# |
| 520 |
|
sad16_ia64: |
| 521 |
|
alloc r1 = ar.pfs, 4, 76, 0, 0 |
| 522 |
|
mov r2 = pr |
| 523 |
|
dep r14 = r0, r33, 0, 3 // r14 = (r33 div 8)*8 (aligned version of ref) |
| 524 |
|
dep.z r31 = r33, 0, 3 // r31 = r33 mod 8 (misalignment of ref) |
| 525 |
|
;; |
| 526 |
|
mov r64 = r34 //(1) calculate multiples of stride |
| 527 |
|
shl r65 = r34, 1 //(2) for being able to load all the |
| 528 |
|
shladd r66 = r34, 1, r34 //(3) data at once |
| 529 |
|
shl r67 = r34, 2 //(4) |
| 530 |
|
shladd r68 = r34, 2, r34 //(5) |
| 531 |
|
shl r71 = r34, 3 //(8) |
| 532 |
|
shladd r72 = r34, 3, r34 //(9) |
| 533 |
|
;; |
| 534 |
|
shl r69 = r66, 1 //(6) |
| 535 |
|
shladd r70 = r66, 1, r34 //(7) |
| 536 |
|
shl r73 = r68, 1 //(10) |
| 537 |
|
shladd r74 = r68, 1, r34 //(11) |
| 538 |
|
shl r75 = r66, 2 //(12) |
| 539 |
|
shladd r76 = r66, 2, r34 //(13) |
| 540 |
|
shladd r77 = r66, 2, r65 //(14) |
| 541 |
|
shladd r78 = r66, 2, r66 //(15) |
| 542 |
|
;; |
| 543 |
|
cmp.eq p16, p17 = 0, r31 // prepare predicates according to the misalignment |
| 544 |
|
cmp.eq p18, p19 = 2, r31 // ref |
| 545 |
|
cmp.eq p20, p21 = 4, r31 |
| 546 |
|
cmp.eq p22, p23 = 6, r31 |
| 547 |
|
cmp.eq p24, p25 = 1, r31 |
| 548 |
|
cmp.eq p26, p27 = 3, r31 |
| 549 |
|
cmp.eq p28, p29 = 5, r31 |
| 550 |
|
mov r96 = r14 // and calculate all the adresses where we have |
| 551 |
|
mov r33 = r32 // to load from |
| 552 |
|
add r97 = r14, r64 |
| 553 |
|
add r35 = r32, r64 |
| 554 |
|
add r98 = r14, r65 |
| 555 |
|
add r37 = r32, r65 |
| 556 |
|
add r99 = r14, r66 |
| 557 |
|
add r39 = r32, r66 |
| 558 |
|
add r100 = r14, r67 |
| 559 |
|
add r41 = r32, r67 |
| 560 |
|
add r101 = r14, r68 |
| 561 |
|
add r43 = r32, r68 |
| 562 |
|
add r102 = r14, r69 |
| 563 |
|
add r45 = r32, r69 |
| 564 |
|
add r103 = r14, r70 |
| 565 |
|
add r47 = r32, r70 |
| 566 |
|
add r104 = r14, r71 |
| 567 |
|
add r49 = r32, r71 |
| 568 |
|
add r105 = r14, r72 |
| 569 |
|
add r51 = r32, r72 |
| 570 |
|
add r106 = r14, r73 |
| 571 |
|
add r53 = r32, r73 |
| 572 |
|
add r107 = r14, r74 |
| 573 |
|
add r55 = r32, r74 |
| 574 |
|
add r108 = r14, r75 |
| 575 |
|
add r57 = r32, r75 |
| 576 |
|
add r109 = r14, r76 |
| 577 |
|
add r59 = r32, r76 |
| 578 |
|
add r110 = r14, r77 |
| 579 |
|
add r61 = r32, r77 |
| 580 |
|
add r111 = r14, r78 |
| 581 |
|
add r63 = r32, r78 |
| 582 |
|
;; |
| 583 |
|
ld8 r32 = [r33], 8 // Load all the data which is needed for the sad |
| 584 |
|
ld8 r34 = [r35], 8 // in the registers. the goal is to have the array |
| 585 |
|
ld8 r36 = [r37], 8 // adressed by cur in the registers r32 - r63 and |
| 586 |
|
ld8 r38 = [r39], 8 // the aray adressed by ref in the registers |
| 587 |
|
ld8 r40 = [r41], 8 // r64 - r95. The registers r96 - r111 are needed |
| 588 |
|
ld8 r42 = [r43], 8 // to load the aligned 24 bits in which the |
| 589 |
|
ld8 r44 = [r45], 8 // needed misaligned 16 bits must be. |
| 590 |
|
ld8 r46 = [r47], 8 // After loading we start a preprocessing which |
| 591 |
|
ld8 r48 = [r49], 8 // guarantees that the data adressed by ref is in |
| 592 |
|
ld8 r50 = [r51], 8 // the registers r64 - r95. |
| 593 |
|
ld8 r52 = [r53], 8 |
| 594 |
|
ld8 r54 = [r55], 8 |
| 595 |
|
ld8 r56 = [r57], 8 |
| 596 |
|
ld8 r58 = [r59], 8 |
| 597 |
|
ld8 r60 = [r61], 8 |
| 598 |
|
ld8 r62 = [r63], 8 |
| 599 |
|
ld8 r64 = [r96], 8 |
| 600 |
|
ld8 r66 = [r97], 8 |
| 601 |
|
ld8 r68 = [r98], 8 |
| 602 |
|
ld8 r70 = [r99], 8 |
| 603 |
|
ld8 r72 = [r100], 8 |
| 604 |
|
ld8 r74 = [r101], 8 |
| 605 |
|
ld8 r76 = [r102], 8 |
| 606 |
|
ld8 r78 = [r103], 8 |
| 607 |
|
ld8 r80 = [r104], 8 |
| 608 |
|
ld8 r82 = [r105], 8 |
| 609 |
|
ld8 r84 = [r106], 8 |
| 610 |
|
ld8 r86 = [r107], 8 |
| 611 |
|
ld8 r88 = [r108], 8 |
| 612 |
|
ld8 r90 = [r109], 8 |
| 613 |
|
ld8 r92 = [r110], 8 |
| 614 |
|
ld8 r94 = [r111], 8 |
| 615 |
|
;; |
| 616 |
|
ld8 r33 = [r33] |
| 617 |
|
ld8 r35 = [r35] |
| 618 |
|
ld8 r37 = [r37] |
| 619 |
|
ld8 r39 = [r39] |
| 620 |
|
ld8 r41 = [r41] |
| 621 |
|
ld8 r43 = [r43] |
| 622 |
|
ld8 r45 = [r45] |
| 623 |
|
ld8 r47 = [r47] |
| 624 |
|
ld8 r49 = [r49] |
| 625 |
|
ld8 r51 = [r51] |
| 626 |
|
ld8 r53 = [r53] |
| 627 |
|
ld8 r55 = [r55] |
| 628 |
|
ld8 r57 = [r57] |
| 629 |
|
ld8 r59 = [r59] |
| 630 |
|
ld8 r61 = [r61] |
| 631 |
|
ld8 r63 = [r63] |
| 632 |
|
ld8 r65 = [r96], 8 |
| 633 |
|
ld8 r67 = [r97], 8 |
| 634 |
|
ld8 r69 = [r98], 8 |
| 635 |
|
ld8 r71 = [r99], 8 |
| 636 |
|
ld8 r73 = [r100], 8 |
| 637 |
|
ld8 r75 = [r101], 8 |
| 638 |
|
ld8 r77 = [r102], 8 |
| 639 |
|
ld8 r79 = [r103], 8 |
| 640 |
|
ld8 r81 = [r104], 8 |
| 641 |
|
ld8 r83 = [r105], 8 |
| 642 |
|
ld8 r85 = [r106], 8 |
| 643 |
|
ld8 r87 = [r107], 8 |
| 644 |
|
ld8 r89 = [r108], 8 |
| 645 |
|
ld8 r91 = [r109], 8 |
| 646 |
|
ld8 r93 = [r110], 8 |
| 647 |
|
ld8 r95 = [r111], 8 |
| 648 |
|
(p16) br.cond.dptk.many .Lber // If ref is aligned, everything is loaded and we can start the calculation |
| 649 |
|
;; |
| 650 |
|
ld8 r96 = [r96] // If not, we have to load a bit more |
| 651 |
|
ld8 r97 = [r97] |
| 652 |
|
ld8 r98 = [r98] |
| 653 |
|
ld8 r99 = [r99] |
| 654 |
|
ld8 r100 = [r100] |
| 655 |
|
ld8 r101 = [r101] |
| 656 |
|
ld8 r102 = [r102] |
| 657 |
|
ld8 r103 = [r103] |
| 658 |
|
ld8 r104 = [r104] |
| 659 |
|
ld8 r105 = [r105] |
| 660 |
|
ld8 r106 = [r106] |
| 661 |
|
ld8 r107 = [r107] |
| 662 |
|
ld8 r108 = [r108] |
| 663 |
|
ld8 r109 = [r109] |
| 664 |
|
ld8 r110 = [r110] |
| 665 |
|
ld8 r111 = [r111] |
| 666 |
|
(p24) br.cond.dptk.many .Lmod1 // according to the misalignment, we have |
| 667 |
|
(p18) br.cond.dpnt.many .Lmod2 // to jump to different preprocessing routines |
| 668 |
|
(p26) br.cond.dpnt.many .Lmod3 |
| 669 |
|
(p20) br.cond.dpnt.many .Lmod4 |
| 670 |
|
(p28) br.cond.dpnt.many .Lmod5 |
| 671 |
|
(p22) br.cond.dpnt.many .Lmod6 |
| 672 |
|
;; |
| 673 |
|
.Lmod7: // this jump point is not needed |
| 674 |
|
shrp r64 = r65, r64, 56 // in these blocks, we do the preprocessing |
| 675 |
|
shrp r65 = r96, r65, 56 |
| 676 |
|
shrp r66 = r67, r66, 56 |
| 677 |
|
shrp r67 = r97, r67, 56 |
| 678 |
|
shrp r68 = r69, r68, 56 |
| 679 |
|
shrp r69 = r98, r69, 56 |
| 680 |
|
shrp r70 = r71, r70, 56 |
| 681 |
|
shrp r71 = r99, r71, 56 |
| 682 |
|
shrp r72 = r73, r72, 56 |
| 683 |
|
shrp r73 = r100, r73, 56 |
| 684 |
|
shrp r74 = r75, r74, 56 |
| 685 |
|
shrp r75 = r101, r75, 56 |
| 686 |
|
shrp r76 = r77, r76, 56 |
| 687 |
|
shrp r77 = r102, r77, 56 |
| 688 |
|
shrp r78 = r79, r78, 56 |
| 689 |
|
shrp r79 = r103, r79, 56 |
| 690 |
|
shrp r80 = r81, r80, 56 |
| 691 |
|
shrp r81 = r104, r81, 56 |
| 692 |
|
shrp r82 = r83, r82, 56 |
| 693 |
|
shrp r83 = r105, r83, 56 |
| 694 |
|
shrp r84 = r85, r84, 56 |
| 695 |
|
shrp r85 = r106, r85, 56 |
| 696 |
|
shrp r86 = r87, r86, 56 |
| 697 |
|
shrp r87 = r107, r87, 56 |
| 698 |
|
shrp r88 = r89, r88, 56 |
| 699 |
|
shrp r89 = r108, r89, 56 |
| 700 |
|
shrp r90 = r91, r90, 56 |
| 701 |
|
shrp r91 = r109, r91, 56 |
| 702 |
|
shrp r92 = r93, r92, 56 |
| 703 |
|
shrp r93 = r110, r93, 56 |
| 704 |
|
shrp r94 = r95, r94, 56 |
| 705 |
|
shrp r95 = r111, r95, 56 |
| 706 |
|
br.cond.sptk.many .Lber // and then we jump to the calculation |
| 707 |
|
;; |
| 708 |
|
.Lmod6: |
| 709 |
|
shrp r64 = r65, r64, 48 |
| 710 |
|
shrp r65 = r96, r65, 48 |
| 711 |
|
shrp r66 = r67, r66, 48 |
| 712 |
|
shrp r67 = r97, r67, 48 |
| 713 |
|
shrp r68 = r69, r68, 48 |
| 714 |
|
shrp r69 = r98, r69, 48 |
| 715 |
|
shrp r70 = r71, r70, 48 |
| 716 |
|
shrp r71 = r99, r71, 48 |
| 717 |
|
shrp r72 = r73, r72, 48 |
| 718 |
|
shrp r73 = r100, r73, 48 |
| 719 |
|
shrp r74 = r75, r74, 48 |
| 720 |
|
shrp r75 = r101, r75, 48 |
| 721 |
|
shrp r76 = r77, r76, 48 |
| 722 |
|
shrp r77 = r102, r77, 48 |
| 723 |
|
shrp r78 = r79, r78, 48 |
| 724 |
|
shrp r79 = r103, r79, 48 |
| 725 |
|
shrp r80 = r81, r80, 48 |
| 726 |
|
shrp r81 = r104, r81, 48 |
| 727 |
|
shrp r82 = r83, r82, 48 |
| 728 |
|
shrp r83 = r105, r83, 48 |
| 729 |
|
shrp r84 = r85, r84, 48 |
| 730 |
|
shrp r85 = r106, r85, 48 |
| 731 |
|
shrp r86 = r87, r86, 48 |
| 732 |
|
shrp r87 = r107, r87, 48 |
| 733 |
|
shrp r88 = r89, r88, 48 |
| 734 |
|
shrp r89 = r108, r89, 48 |
| 735 |
|
shrp r90 = r91, r90, 48 |
| 736 |
|
shrp r91 = r109, r91, 48 |
| 737 |
|
shrp r92 = r93, r92, 48 |
| 738 |
|
shrp r93 = r110, r93, 48 |
| 739 |
|
shrp r94 = r95, r94, 48 |
| 740 |
|
shrp r95 = r111, r95, 48 |
| 741 |
|
br.cond.sptk.many .Lber |
| 742 |
|
;; |
| 743 |
|
.Lmod5: |
| 744 |
|
shrp r64 = r65, r64, 40 |
| 745 |
|
shrp r65 = r96, r65, 40 |
| 746 |
|
shrp r66 = r67, r66, 40 |
| 747 |
|
shrp r67 = r97, r67, 40 |
| 748 |
|
shrp r68 = r69, r68, 40 |
| 749 |
|
shrp r69 = r98, r69, 40 |
| 750 |
|
shrp r70 = r71, r70, 40 |
| 751 |
|
shrp r71 = r99, r71, 40 |
| 752 |
|
shrp r72 = r73, r72, 40 |
| 753 |
|
shrp r73 = r100, r73, 40 |
| 754 |
|
shrp r74 = r75, r74, 40 |
| 755 |
|
shrp r75 = r101, r75, 40 |
| 756 |
|
shrp r76 = r77, r76, 40 |
| 757 |
|
shrp r77 = r102, r77, 40 |
| 758 |
|
shrp r78 = r79, r78, 40 |
| 759 |
|
shrp r79 = r103, r79, 40 |
| 760 |
|
shrp r80 = r81, r80, 40 |
| 761 |
|
shrp r81 = r104, r81, 40 |
| 762 |
|
shrp r82 = r83, r82, 40 |
| 763 |
|
shrp r83 = r105, r83, 40 |
| 764 |
|
shrp r84 = r85, r84, 40 |
| 765 |
|
shrp r85 = r106, r85, 40 |
| 766 |
|
shrp r86 = r87, r86, 40 |
| 767 |
|
shrp r87 = r107, r87, 40 |
| 768 |
|
shrp r88 = r89, r88, 40 |
| 769 |
|
shrp r89 = r108, r89, 40 |
| 770 |
|
shrp r90 = r91, r90, 40 |
| 771 |
|
shrp r91 = r109, r91, 40 |
| 772 |
|
shrp r92 = r93, r92, 40 |
| 773 |
|
shrp r93 = r110, r93, 40 |
| 774 |
|
shrp r94 = r95, r94, 40 |
| 775 |
|
shrp r95 = r111, r95, 40 |
| 776 |
|
br.cond.sptk.many .Lber |
| 777 |
|
;; |
| 778 |
|
.Lmod4: |
| 779 |
|
shrp r64 = r65, r64, 32 |
| 780 |
|
shrp r65 = r96, r65, 32 |
| 781 |
|
shrp r66 = r67, r66, 32 |
| 782 |
|
shrp r67 = r97, r67, 32 |
| 783 |
|
shrp r68 = r69, r68, 32 |
| 784 |
|
shrp r69 = r98, r69, 32 |
| 785 |
|
shrp r70 = r71, r70, 32 |
| 786 |
|
shrp r71 = r99, r71, 32 |
| 787 |
|
shrp r72 = r73, r72, 32 |
| 788 |
|
shrp r73 = r100, r73, 32 |
| 789 |
|
shrp r74 = r75, r74, 32 |
| 790 |
|
shrp r75 = r101, r75, 32 |
| 791 |
|
shrp r76 = r77, r76, 32 |
| 792 |
|
shrp r77 = r102, r77, 32 |
| 793 |
|
shrp r78 = r79, r78, 32 |
| 794 |
|
shrp r79 = r103, r79, 32 |
| 795 |
|
shrp r80 = r81, r80, 32 |
| 796 |
|
shrp r81 = r104, r81, 32 |
| 797 |
|
shrp r82 = r83, r82, 32 |
| 798 |
|
shrp r83 = r105, r83, 32 |
| 799 |
|
shrp r84 = r85, r84, 32 |
| 800 |
|
shrp r85 = r106, r85, 32 |
| 801 |
|
shrp r86 = r87, r86, 32 |
| 802 |
|
shrp r87 = r107, r87, 32 |
| 803 |
|
shrp r88 = r89, r88, 32 |
| 804 |
|
shrp r89 = r108, r89, 32 |
| 805 |
|
shrp r90 = r91, r90, 32 |
| 806 |
|
shrp r91 = r109, r91, 32 |
| 807 |
|
shrp r92 = r93, r92, 32 |
| 808 |
|
shrp r93 = r110, r93, 32 |
| 809 |
|
shrp r94 = r95, r94, 32 |
| 810 |
|
shrp r95 = r111, r95, 32 |
| 811 |
|
br.cond.sptk.many .Lber |
| 812 |
|
;; |
| 813 |
|
.Lmod3: |
| 814 |
|
shrp r64 = r65, r64, 24 |
| 815 |
|
shrp r65 = r96, r65, 24 |
| 816 |
|
shrp r66 = r67, r66, 24 |
| 817 |
|
shrp r67 = r97, r67, 24 |
| 818 |
|
shrp r68 = r69, r68, 24 |
| 819 |
|
shrp r69 = r98, r69, 24 |
| 820 |
|
shrp r70 = r71, r70, 24 |
| 821 |
|
shrp r71 = r99, r71, 24 |
| 822 |
|
shrp r72 = r73, r72, 24 |
| 823 |
|
shrp r73 = r100, r73, 24 |
| 824 |
|
shrp r74 = r75, r74, 24 |
| 825 |
|
shrp r75 = r101, r75, 24 |
| 826 |
|
shrp r76 = r77, r76, 24 |
| 827 |
|
shrp r77 = r102, r77, 24 |
| 828 |
|
shrp r78 = r79, r78, 24 |
| 829 |
|
shrp r79 = r103, r79, 24 |
| 830 |
|
shrp r80 = r81, r80, 24 |
| 831 |
|
shrp r81 = r104, r81, 24 |
| 832 |
|
shrp r82 = r83, r82, 24 |
| 833 |
|
shrp r83 = r105, r83, 24 |
| 834 |
|
shrp r84 = r85, r84, 24 |
| 835 |
|
shrp r85 = r106, r85, 24 |
| 836 |
|
shrp r86 = r87, r86, 24 |
| 837 |
|
shrp r87 = r107, r87, 24 |
| 838 |
|
shrp r88 = r89, r88, 24 |
| 839 |
|
shrp r89 = r108, r89, 24 |
| 840 |
|
shrp r90 = r91, r90, 24 |
| 841 |
|
shrp r91 = r109, r91, 24 |
| 842 |
|
shrp r92 = r93, r92, 24 |
| 843 |
|
shrp r93 = r110, r93, 24 |
| 844 |
|
shrp r94 = r95, r94, 24 |
| 845 |
|
shrp r95 = r111, r95, 24 |
| 846 |
|
br.cond.sptk.many .Lber |
| 847 |
|
;; |
| 848 |
|
.Lmod2: |
| 849 |
|
shrp r64 = r65, r64, 16 |
| 850 |
|
shrp r65 = r96, r65, 16 |
| 851 |
|
shrp r66 = r67, r66, 16 |
| 852 |
|
shrp r67 = r97, r67, 16 |
| 853 |
|
shrp r68 = r69, r68, 16 |
| 854 |
|
shrp r69 = r98, r69, 16 |
| 855 |
|
shrp r70 = r71, r70, 16 |
| 856 |
|
shrp r71 = r99, r71, 16 |
| 857 |
|
shrp r72 = r73, r72, 16 |
| 858 |
|
shrp r73 = r100, r73, 16 |
| 859 |
|
shrp r74 = r75, r74, 16 |
| 860 |
|
shrp r75 = r101, r75, 16 |
| 861 |
|
shrp r76 = r77, r76, 16 |
| 862 |
|
shrp r77 = r102, r77, 16 |
| 863 |
|
shrp r78 = r79, r78, 16 |
| 864 |
|
shrp r79 = r103, r79, 16 |
| 865 |
|
shrp r80 = r81, r80, 16 |
| 866 |
|
shrp r81 = r104, r81, 16 |
| 867 |
|
shrp r82 = r83, r82, 16 |
| 868 |
|
shrp r83 = r105, r83, 16 |
| 869 |
|
shrp r84 = r85, r84, 16 |
| 870 |
|
shrp r85 = r106, r85, 16 |
| 871 |
|
shrp r86 = r87, r86, 16 |
| 872 |
|
shrp r87 = r107, r87, 16 |
| 873 |
|
shrp r88 = r89, r88, 16 |
| 874 |
|
shrp r89 = r108, r89, 16 |
| 875 |
|
shrp r90 = r91, r90, 16 |
| 876 |
|
shrp r91 = r109, r91, 16 |
| 877 |
|
shrp r92 = r93, r92, 16 |
| 878 |
|
shrp r93 = r110, r93, 16 |
| 879 |
|
shrp r94 = r95, r94, 16 |
| 880 |
|
shrp r95 = r111, r95, 16 |
| 881 |
|
br.cond.sptk.many .Lber |
| 882 |
|
;; |
| 883 |
|
.Lmod1: |
| 884 |
|
shrp r64 = r65, r64, 8 |
| 885 |
|
shrp r65 = r96, r65, 8 |
| 886 |
|
shrp r66 = r67, r66, 8 |
| 887 |
|
shrp r67 = r97, r67, 8 |
| 888 |
|
shrp r68 = r69, r68, 8 |
| 889 |
|
shrp r69 = r98, r69, 8 |
| 890 |
|
shrp r70 = r71, r70, 8 |
| 891 |
|
shrp r71 = r99, r71, 8 |
| 892 |
|
shrp r72 = r73, r72, 8 |
| 893 |
|
shrp r73 = r100, r73, 8 |
| 894 |
|
shrp r74 = r75, r74, 8 |
| 895 |
|
shrp r75 = r101, r75, 8 |
| 896 |
|
shrp r76 = r77, r76, 8 |
| 897 |
|
shrp r77 = r102, r77, 8 |
| 898 |
|
shrp r78 = r79, r78, 8 |
| 899 |
|
shrp r79 = r103, r79, 8 |
| 900 |
|
shrp r80 = r81, r80, 8 |
| 901 |
|
shrp r81 = r104, r81, 8 |
| 902 |
|
shrp r82 = r83, r82, 8 |
| 903 |
|
shrp r83 = r105, r83, 8 |
| 904 |
|
shrp r84 = r85, r84, 8 |
| 905 |
|
shrp r85 = r106, r85, 8 |
| 906 |
|
shrp r86 = r87, r86, 8 |
| 907 |
|
shrp r87 = r107, r87, 8 |
| 908 |
|
shrp r88 = r89, r88, 8 |
| 909 |
|
shrp r89 = r108, r89, 8 |
| 910 |
|
shrp r90 = r91, r90, 8 |
| 911 |
|
shrp r91 = r109, r91, 8 |
| 912 |
|
shrp r92 = r93, r92, 8 |
| 913 |
|
shrp r93 = r110, r93, 8 |
| 914 |
|
shrp r94 = r95, r94, 8 |
| 915 |
|
shrp r95 = r111, r95, 8 |
| 916 |
|
.Lber: |
| 917 |
|
;; |
| 918 |
|
psad1 r32 = r32, r64 // Here we do the calculation. |
| 919 |
|
psad1 r33 = r33, r65 // The machine is providing a fast method |
| 920 |
|
psad1 r34 = r34, r66 // for calculating sad, so we use it |
| 921 |
|
psad1 r35 = r35, r67 |
| 922 |
|
psad1 r36 = r36, r68 |
| 923 |
|
psad1 r37 = r37, r69 |
| 924 |
|
psad1 r38 = r38, r70 |
| 925 |
|
psad1 r39 = r39, r71 |
| 926 |
|
psad1 r40 = r40, r72 |
| 927 |
|
psad1 r41 = r41, r73 |
| 928 |
|
psad1 r42 = r42, r74 |
| 929 |
|
psad1 r43 = r43, r75 |
| 930 |
|
psad1 r44 = r44, r76 |
| 931 |
|
psad1 r45 = r45, r77 |
| 932 |
|
psad1 r46 = r46, r78 |
| 933 |
|
psad1 r47 = r47, r79 |
| 934 |
|
psad1 r48 = r48, r80 |
| 935 |
|
psad1 r49 = r49, r81 |
| 936 |
|
psad1 r50 = r50, r82 |
| 937 |
|
psad1 r51 = r51, r83 |
| 938 |
|
psad1 r52 = r52, r84 |
| 939 |
|
psad1 r53 = r53, r85 |
| 940 |
|
psad1 r54 = r54, r86 |
| 941 |
|
psad1 r55 = r55, r87 |
| 942 |
|
psad1 r56 = r56, r88 |
| 943 |
|
psad1 r57 = r57, r89 |
| 944 |
|
psad1 r58 = r58, r90 |
| 945 |
|
psad1 r59 = r59, r91 |
| 946 |
|
psad1 r60 = r60, r92 |
| 947 |
|
psad1 r61 = r61, r93 |
| 948 |
|
psad1 r62 = r62, r94 |
| 949 |
|
psad1 r63 = r63, r95 |
| 950 |
|
;; |
| 951 |
|
add r32 = r32, r63 // at last, we have to sum up |
| 952 |
|
add r33 = r33, r62 // in 5 stages |
| 953 |
|
add r34 = r34, r61 |
| 954 |
|
add r35 = r35, r60 |
| 955 |
|
add r36 = r36, r59 |
| 956 |
|
add r37 = r37, r58 |
| 957 |
|
add r38 = r38, r57 |
| 958 |
|
add r39 = r39, r56 |
| 959 |
|
add r40 = r40, r55 |
| 960 |
|
add r41 = r41, r54 |
| 961 |
|
add r42 = r42, r53 |
| 962 |
|
add r43 = r43, r52 |
| 963 |
|
add r44 = r44, r51 |
| 964 |
|
add r45 = r45, r50 |
| 965 |
|
add r46 = r46, r49 |
| 966 |
|
add r47 = r47, r48 |
| 967 |
|
;; |
| 968 |
|
add r32 = r32, r47 |
| 969 |
|
add r33 = r33, r46 |
| 970 |
|
add r34 = r34, r45 |
| 971 |
|
add r35 = r35, r44 |
| 972 |
|
add r36 = r36, r43 |
| 973 |
|
add r37 = r37, r42 |
| 974 |
|
add r38 = r38, r41 |
| 975 |
|
add r39 = r39, r40 |
| 976 |
|
;; |
| 977 |
|
add r32 = r32, r39 |
| 978 |
|
add r33 = r33, r38 |
| 979 |
|
add r34 = r34, r37 |
| 980 |
|
add r35 = r35, r36 |
| 981 |
|
;; |
| 982 |
|
add r32 = r32, r35 |
| 983 |
|
add r33 = r33, r34 |
| 984 |
|
;; |
| 985 |
|
add r8 = r32, r33 // and store the result in r8 |
| 986 |
|
mov pr = r2, -1 |
| 987 |
|
mov ar.pfs = r1 |
| 988 |
|
br.ret.sptk.many b0 |
| 989 |
|
.endp sad16_ia64# |
| 990 |
|
|
| 991 |
|
|
| 992 |
|
|
| 993 |
|
|
| 994 |
|
.align 16 |
| 995 |
|
.global sad8_ia64# |
| 996 |
|
.proc sad8_ia64# |
| 997 |
|
sad8_ia64: |
| 998 |
|
alloc r1 = ar.pfs, 3, 21, 0, 0 |
| 999 |
|
mov r2 = pr |
| 1000 |
|
dep r14 = r0, r33, 0, 3 // calculate aligned version of ref |
| 1001 |
|
dep.z r31 = r33, 0, 3 // calculate misalignment of ref |
| 1002 |
|
;; |
| 1003 |
|
mov r40 = r34 //(1) calculate multiples of stride |
| 1004 |
|
shl r41 = r34, 1 //(2) |
| 1005 |
|
shladd r42 = r34, 1, r34 //(3) |
| 1006 |
|
shl r43 = r34, 2 //(4) |
| 1007 |
|
shladd r44 = r34, 2, r34 //(5) |
| 1008 |
|
;; |
| 1009 |
|
cmp.eq p16, p17 = 0, r31 // set predicates according to the misalignment of ref |
| 1010 |
|
cmp.eq p18, p19 = 2, r31 |
| 1011 |
|
shl r45 = r42, 1 //(6) |
| 1012 |
|
cmp.eq p20, p21 = 4, r31 |
| 1013 |
|
cmp.eq p22, p23 = 6, r31 |
| 1014 |
|
shladd r46 = r42, 1, r34 //(7) |
| 1015 |
|
cmp.eq p24, p25 = 1, r31 |
| 1016 |
|
cmp.eq p26, p27 = 3, r31 |
| 1017 |
|
cmp.eq p28, p29 = 5, r31 |
| 1018 |
|
;; |
| 1019 |
|
mov r48 = r14 // calculate memory adresses of data |
| 1020 |
|
add r33 = r32, r40 |
| 1021 |
|
add r49 = r14, r40 |
| 1022 |
|
add r34 = r32, r41 |
| 1023 |
|
add r50 = r14, r41 |
| 1024 |
|
add r35 = r32, r42 |
| 1025 |
|
add r51 = r14, r42 |
| 1026 |
|
add r36 = r32, r43 |
| 1027 |
|
add r52 = r14, r43 |
| 1028 |
|
add r37 = r32, r44 |
| 1029 |
|
add r53 = r14, r44 |
| 1030 |
|
add r38 = r32, r45 |
| 1031 |
|
add r54 = r14, r45 |
| 1032 |
|
add r39 = r32, r46 |
| 1033 |
|
add r55 = r14, r46 |
| 1034 |
|
;; |
| 1035 |
|
ld8 r32 = [r32] // load everythingund alles wird geladen |
| 1036 |
|
ld8 r33 = [r33] // cur is located in r32 - r39 |
| 1037 |
|
ld8 r34 = [r34] // ref in r40 - r47 |
| 1038 |
|
ld8 r35 = [r35] |
| 1039 |
|
ld8 r36 = [r36] |
| 1040 |
|
ld8 r37 = [r37] |
| 1041 |
|
ld8 r38 = [r38] |
| 1042 |
|
ld8 r39 = [r39] |
| 1043 |
|
ld8 r40 = [r48] ,8 |
| 1044 |
|
ld8 r41 = [r49] ,8 |
| 1045 |
|
ld8 r42 = [r50] ,8 |
| 1046 |
|
ld8 r43 = [r51] ,8 |
| 1047 |
|
ld8 r44 = [r52] ,8 |
| 1048 |
|
ld8 r45 = [r53] ,8 |
| 1049 |
|
ld8 r46 = [r54] ,8 |
| 1050 |
|
ld8 r47 = [r55] ,8 |
| 1051 |
|
(p16) br.cond.dptk.many .Lber2 // if ref is aligned, we can start the calculation |
| 1052 |
|
;; |
| 1053 |
|
ld8 r48 = [r48] // if not, we have to load some more |
| 1054 |
|
ld8 r49 = [r49] // because of the alignment of ld8 |
| 1055 |
|
ld8 r50 = [r50] |
| 1056 |
|
ld8 r51 = [r51] |
| 1057 |
|
ld8 r52 = [r52] |
| 1058 |
|
ld8 r53 = [r53] |
| 1059 |
|
ld8 r54 = [r54] |
| 1060 |
|
ld8 r55 = [r55] |
| 1061 |
|
(p24) br.cond.dptk.many .Lmode1 |
| 1062 |
|
(p18) br.cond.dpnt.many .Lmode2 |
| 1063 |
|
(p26) br.cond.dpnt.many .Lmode3 |
| 1064 |
|
(p20) br.cond.dpnt.many .Lmode4 |
| 1065 |
|
(p28) br.cond.dpnt.many .Lmode5 |
| 1066 |
|
(p22) br.cond.dpnt.many .Lmode6 |
| 1067 |
|
;; |
| 1068 |
|
.Lmode7: // this jump piont is not needed, it is for better understandment |
| 1069 |
|
shrp r40 = r48, r40, 56 // here we do some preprocessing on the data |
| 1070 |
|
shrp r41 = r49, r41, 56 // this is because of the alignment problem of ref |
| 1071 |
|
shrp r42 = r50, r42, 56 |
| 1072 |
|
shrp r43 = r51, r43, 56 |
| 1073 |
|
shrp r44 = r52, r44, 56 |
| 1074 |
|
shrp r45 = r53, r45, 56 |
| 1075 |
|
shrp r46 = r54, r46, 56 |
| 1076 |
|
shrp r47 = r55, r47, 56 |
| 1077 |
|
br.cond.sptk.many .Lber2 |
| 1078 |
|
;; |
| 1079 |
|
.Lmode6: |
| 1080 |
|
shrp r40 = r48, r40, 48 |
| 1081 |
|
shrp r41 = r49, r41, 48 |
| 1082 |
|
shrp r42 = r50, r42, 48 |
| 1083 |
|
shrp r43 = r51, r43, 48 |
| 1084 |
|
shrp r44 = r52, r44, 48 |
| 1085 |
|
shrp r45 = r53, r45, 48 |
| 1086 |
|
shrp r46 = r54, r46, 48 |
| 1087 |
|
shrp r47 = r55, r47, 48 |
| 1088 |
|
br.cond.sptk.many .Lber2 |
| 1089 |
|
;; |
| 1090 |
|
.Lmode5: |
| 1091 |
|
shrp r40 = r48, r40, 40 |
| 1092 |
|
shrp r41 = r49, r41, 40 |
| 1093 |
|
shrp r42 = r50, r42, 40 |
| 1094 |
|
shrp r43 = r51, r43, 40 |
| 1095 |
|
shrp r44 = r52, r44, 40 |
| 1096 |
|
shrp r45 = r53, r45, 40 |
| 1097 |
|
shrp r46 = r54, r46, 40 |
| 1098 |
|
shrp r47 = r55, r47, 40 |
| 1099 |
|
br.cond.sptk.many .Lber2 |
| 1100 |
|
;; |
| 1101 |
|
.Lmode4: |
| 1102 |
|
shrp r40 = r48, r40, 32 |
| 1103 |
|
shrp r41 = r49, r41, 32 |
| 1104 |
|
shrp r42 = r50, r42, 32 |
| 1105 |
|
shrp r43 = r51, r43, 32 |
| 1106 |
|
shrp r44 = r52, r44, 32 |
| 1107 |
|
shrp r45 = r53, r45, 32 |
| 1108 |
|
shrp r46 = r54, r46, 32 |
| 1109 |
|
shrp r47 = r55, r47, 32 |
| 1110 |
|
br.cond.sptk.many .Lber2 |
| 1111 |
|
;; |
| 1112 |
|
.Lmode3: |
| 1113 |
|
shrp r40 = r48, r40, 24 |
| 1114 |
|
shrp r41 = r49, r41, 24 |
| 1115 |
|
shrp r42 = r50, r42, 24 |
| 1116 |
|
shrp r43 = r51, r43, 24 |
| 1117 |
|
shrp r44 = r52, r44, 24 |
| 1118 |
|
shrp r45 = r53, r45, 24 |
| 1119 |
|
shrp r46 = r54, r46, 24 |
| 1120 |
|
shrp r47 = r55, r47, 24 |
| 1121 |
|
br.cond.sptk.many .Lber2 |
| 1122 |
|
;; |
| 1123 |
|
.Lmode2: |
| 1124 |
|
shrp r40 = r48, r40, 16 |
| 1125 |
|
shrp r41 = r49, r41, 16 |
| 1126 |
|
shrp r42 = r50, r42, 16 |
| 1127 |
|
shrp r43 = r51, r43, 16 |
| 1128 |
|
shrp r44 = r52, r44, 16 |
| 1129 |
|
shrp r45 = r53, r45, 16 |
| 1130 |
|
shrp r46 = r54, r46, 16 |
| 1131 |
|
shrp r47 = r55, r47, 16 |
| 1132 |
|
br.cond.sptk.many .Lber2 |
| 1133 |
|
;; |
| 1134 |
|
.Lmode1: |
| 1135 |
|
shrp r40 = r48, r40, 8 |
| 1136 |
|
shrp r41 = r49, r41, 8 |
| 1137 |
|
shrp r42 = r50, r42, 8 |
| 1138 |
|
shrp r43 = r51, r43, 8 |
| 1139 |
|
shrp r44 = r52, r44, 8 |
| 1140 |
|
shrp r45 = r53, r45, 8 |
| 1141 |
|
shrp r46 = r54, r46, 8 |
| 1142 |
|
shrp r47 = r55, r47, 8 |
| 1143 |
|
.Lber2: |
| 1144 |
|
;; |
| 1145 |
|
psad1 r32 = r32, r40 // we start calculating sad |
| 1146 |
|
psad1 r33 = r33, r41 // using th psad1 command of IA64 |
| 1147 |
|
psad1 r34 = r34, r42 |
| 1148 |
|
psad1 r35 = r35, r43 |
| 1149 |
|
psad1 r36 = r36, r44 |
| 1150 |
|
psad1 r37 = r37, r45 |
| 1151 |
|
psad1 r38 = r38, r46 |
| 1152 |
|
psad1 r39 = r39, r47 |
| 1153 |
|
;; |
| 1154 |
|
add r32 = r32, r33 // then we sum up everything |
| 1155 |
|
add r33 = r34, r35 |
| 1156 |
|
add r34 = r36, r37 |
| 1157 |
|
add r35 = r38, r39 |
| 1158 |
|
;; |
| 1159 |
|
add r32 = r32, r33 |
| 1160 |
|
add r33 = r34, r35 |
| 1161 |
|
;; |
| 1162 |
|
add r8 = r32, r33 // and store the result un r8 |
| 1163 |
|
mov pr = r2, -1 |
| 1164 |
|
mov ar.pfs = r1 |
| 1165 |
|
br.ret.sptk.many b0 |
| 1166 |
|
.endp sad8_ia64# |
Parent Directory
| 
Revision Log
| 
Patch