https://bugs.libre-soc.org/show_bug.cgi?id=985

[libreriscv.git] / openpower / sv / twin_butterfly.mdwn

diff --git a/openpower/sv/twin_butterfly.mdwn b/openpower/sv/twin_butterfly.mdwn
index a2a7b8d7f3e964fd63b350cb78a82c8e6dc77c52..516f601f3c2fd8b9df945a95ac76e896842ea898 100644 (file)
--- a/openpower/sv/twin_butterfly.mdwn
+++ b/openpower/sv/twin_butterfly.mdwn
@@ -57,7 +57,7 @@ one would just have to call the same instruction with different order a,
 b and a different constant c.
 
 Example taken from libvpx
-<https://chromium.googlesource.com/webm/libvpx/+/refs/heads/main/vpx_dsp/fwd_txfm.c#132>:
+<https://chromium.googlesource.com/webm/libvpx/+/refs/tags/v1.13.0/vpx_dsp/fwd_txfm.c#132>:
 
 ```
     #include <stdint.h>
@@ -97,39 +97,32 @@ A-Form
     | PO   |  RT  |   RA   |   RB  |   SH   |   XO |Rc |
 ```
 
-* maddsubrs  RT,RA,SH,RB
+* maddsubrs  RT,RA,RB,SH
 
 Pseudo-code:
 
 ```
     n <- SH
-    sum <- (RT) + (RA)
-    diff <- (RT) - (RA)
+    sum <- (RT[0] || RT) + (RA[0] || RA)
+    diff <- (RT[0] || RT) - (RA[0] || RA)
     prod1 <- MULS(RB, sum)
-    prod1_lo <- prod1[XLEN:(XLEN*2)-1]
     prod2 <- MULS(RB, diff)
-    prod2_lo <- prod2[XLEN:(XLEN*2)-1]
     if n = 0 then
+        prod1_lo <- prod1[XLEN+1:(XLEN*2)]
+        prod2_lo <- prod2[XLEN+1:(XLEN*2)]
         RT <- prod1_lo
         RS <- prod2_lo
     else
-        round <- [0]*XLEN
-        round[XLEN -n] <- 1
-        prod1_lo <- prod1_lo + round
-        prod2_lo <- prod2_lo + round
-        m <- MASK(n, (XLEN-1))
-        res1 <- ROTL64(prod1_lo, XLEN-n) & m
-        res2 <- ROTL64(prod2_lo, XLEN-n) & m
-        signbit1 <- prod1_lo[0]
-        signbit2 <- prod2_lo[0]
-        smask1 <- ([signbit1]*XLEN) & ¬m
-        smask2 <- ([signbit2]*XLEN) & ¬m
-        RT <- (res1 | smask1)
-        RS <- (res2 | smask2)
+        round <- [0]*(XLEN*2 + 1)
+        round[XLEN*2 - n + 1] <- 1
+        prod1 <- prod1 + round
+        prod2 <- prod2 + round
+        res1 <- prod1[XLEN - n + 1:XLEN*2 - n]
+        res2 <- prod2[XLEN - n + 1:XLEN*2 - n]
+        RT <- res1
+        RS <- res2
 ```
 
-Note that if Rc=1 an Illegal Instruction is raised.  Rc=1 is `RESERVED`
-
 Similar to `RTp`, this instruction produces an implicit result, `RS`,
 which under Scalar circumstances is defined as `RT+1`.  For SVP64 if
 `RT` is a Vector, `RS` begins immediately after the Vector `RT` where
@@ -141,6 +134,81 @@ Special Registers Altered:
     None
 ```
 
+# [DRAFT] Integer Butterfly Multiply Add and Round Shift FFT/DCT
+
+A-Form
+
+* maddrs  RT,RA,RB,SH
+
+Pseudo-code:
+
+```
+    n <- SH
+    prod <- MULS(RB, RA)
+    if n = 0 then
+        prod_lo <- prod[XLEN:(XLEN*2) - 1]
+        RT <- (RT) + prod_lo
+    else
+        res[0:XLEN*2-1] <- (EXTSXL((RT)[0], 1) || (RT)) + prod
+        round <- [0]*XLEN*2
+        round[XLEN*2 - n] <- 1
+        res <- res + round
+        RT <- res[XLEN - n:XLEN*2 - n -1]
+```
+
+Special Registers Altered:
+
+    None
+
+# [DRAFT] Integer Butterfly Multiply Sub and Round Shift FFT/DCT
+
+A-Form
+
+* msubrs  RT,RA,RB,SH
+
+Pseudo-code:
+
+```
+    n <- SH
+    prod <- MULS(RB, RA)
+    if n = 0 then
+        prod_lo <- prod[XLEN:(XLEN*2) - 1]
+        RT <- (RT) - prod_lo
+    else
+        res[0:XLEN*2-1] <- (EXTSXL((RT)[0], 1) || (RT)) - prod
+        round <- [0]*XLEN*2
+        round[XLEN*2 - n] <- 1
+        res <- res + round
+        RT <- res[XLEN - n:XLEN*2 - n -1]
+```
+
+Special Registers Altered:
+
+    None
+
+
+This pair of instructions is supposed to be used in complement to the maddsubrs
+to produce the double-coefficient butterfly instruction. In order for that
+to work, instead of passing c2 as coefficient, we have to pass c2-c1 instead.
+
+In essence, we are calculating the quantity `a * c1 +/- b * c1` first, with
+`maddsubrs` *without* shifting (so `SH=0`) and then we add/sub `b * (c2-c1)`
+from the previous `RT`, and *then* do the shifting.
+
+In the following example, assume `a` in `R1`, `b` in `R10`, `c1` in `R11` and `c2 - c1` in `R12`.
+The first instruction will put `a * c1 + b * c1` in `R1` (`RT`), `a * c1 - b * c1` in `RS`
+(here, `RS = RT +1`, so `R2`).
+Then, `maddrs` will add `b * (c2 - c1)` to `R1` (`RT`), and `msubrs` will subtract it from `R2` (`RS`), and then
+round shift right both quantities 14 bits:
+
+```
+    maddsubrs 1,10,0,11
+    maddrs 1,10,12,14
+    msubrs 2,10,12,14
+```
+
+In scalar code, that would take ~16 instructions for both operations.
+
 -------
 
 \newpage{}