paired.h

Go to the documentation of this file.

/*
        libbroadway - A general purpose library to control the Wii.
        Paired Singles manipulation

Copyright (C) 2010      Alex Marshall <trap15@raidenii.net>

# This code is licensed to you under the terms of the GNU GPL, version 2;
# see file COPYING or http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*/

#ifndef __PAIRED_H__
#define __PAIRED_H__

typedef enum {
        GQR_TYPE_FLOAT = 0,     
        GQR_TYPE_U8 = 4,        
        GQR_TYPE_U16,           
        GQR_TYPE_S8,            
        GQR_TYPE_S16,           
} gqr_type_t;

void paired_set_gqr(int gqr, int mode, gqr_type_t type, int scale);
void paired_get_gqr(int gqr, int mode, gqr_type_t *type, int *scale);

#define paired_load(gqr, data, single) ({               \
        double pair;                                    \
        asm volatile                                    \
        ("      psq_lx          %0, 0, %1, 0, %3\n"     \
         : "=f"(pair) /* The FPR target */              \
         : "rm"(data), "i"(single), "i"(gqr)            \
        );                                              \
        pair;                                           \
})
/* Har har, I used indexed format for cheatz */

#define paired_store(gqr, data, single, pair)           \
        asm volatile                                    \
        ("      psq_st          %1, %0, 0, %3\n"        \
         : "=m"(data)                                   \
         : "f"(pair), "i"(single), "i"(gqr)             \
        );

#define paired_abs(pair) ({                     \
        double out;                             \
        asm volatile                            \
        ("      ps_abs          %0, %1\n"       \
         : "=f"(out)                            \
         : "f"(pair)                            \
        );                                      \
        out;                                    \
})

#define paired_nabs(pair) ({                    \
        double out;                             \
        asm volatile                            \
        ("      ps_nabs         %0, %1\n"       \
         : "=f"(out)                            \
         : "f"(pair)                            \
        );                                      \
        out;                                    \
})

#define paired_neg(pair) ({                     \
        double out;                             \
        asm volatile                            \
        ("      ps_neg          %0, %1\n"       \
         : "=f"(out)                            \
         : "f"(pair)                            \
        );                                      \
        out;                                    \
})

#define paired_reciprocal(pair) ({              \
        double out;                             \
        asm volatile                            \
        ("      ps_res          %0, %1\n"       \
         : "=f"(out)                            \
         : "f"(pair)                            \
        );                                      \
        out;                                    \
})

#define paired_sqrt_reciprocal(pair) ({         \
        double out;                             \
        asm volatile                            \
        ("      ps_rsqrte       %0, %1\n"       \
         : "=f"(out)                            \
         : "f"(pair)                            \
        );                                      \
        out;                                    \
})

#define paired_add(pair0, pair1) ({             \
        double out;                             \
        asm volatile                            \
        ("      ps_add          %0, %1, %2\n"   \
         : "=f"(out)                            \
         : "f"(pair0), "f"(pair1)               \
        );                                      \
        out;                                    \
})

#define paired_div(dend, sor) ({                \
        double out;                             \
        asm volatile                            \
        ("      ps_div          %0, %1, %2\n"   \
         : "=f"(out)                            \
         : "f"(dend), "f"(sor)                  \
        );                                      \
        out;                                    \
})

#define paired_mul(pair0, pair1) ({             \
        double out;                             \
        asm volatile                            \
        ("      ps_mul          %0, %1, %2\n"   \
         : "=f"(out)                            \
         : "f"(pair0), "f"(pair1)               \
        );                                      \
        out;                                    \
})

#define paired_sub(uend, hend) ({               \
        double out;                             \
        asm volatile                            \
        ("      ps_sub          %0, %1, %2\n"   \
         : "=f"(out)                            \
         : "f"(uend), "f"(hend)                 \
        );                                      \
        out;                                    \
})

/* TODO: Comparison functions! */

#define paired_madd(mul0, mul1, add) ({                 \
        double out;                                     \
        asm volatile                                    \
        ("      ps_madd         %0, %1, %2, %3\n"       \
         : "=f"(out)                                    \
         : "f"(mul0), "f"(mul1), "f"(add)               \
        );                                              \
        out;                                            \
})

#define paired_madds0(mul0, mul1, add) ({               \
        double out;                                     \
        asm volatile                                    \
        ("      ps_madds0       %0, %1, %2, %3\n"       \
         : "=f"(out)                                    \
         : "f"(mul0), "f"(mul1), "f"(add)               \
        );                                              \
        out;                                            \
})

#define paired_madds1(mul0, mul1, add) ({               \
        double out;                                     \
        asm volatile                                    \
        ("      ps_madds1       %0, %1, %2, %3\n"       \
         : "=f"(out)                                    \
         : "f"(mul0), "f"(mul1), "f"(add)               \
        );                                              \
        out;                                            \
})

#define paired_msub(mul0, mul1, sub) ({                 \
        double out;                                     \
        asm volatile                                    \
        ("      ps_msub         %0, %1, %2, %3\n"       \
         : "=f"(out)                                    \
         : "f"(mul0), "f"(mul1), "f"(sub)               \
        );                                              \
        out;                                            \
})

#define paired_muls0(mul0, mul1) ({                     \
        double out;                                     \
        asm volatile                                    \
        ("      ps_muls0        %0, %1, %2\n"           \
         : "=f"(out)                                    \
         : "f"(mul0), "f"(mul1)                         \
        );                                              \
        out;                                            \
})

#define paired_muls1(mul0, mul1) ({                     \
        double out;                                     \
        asm volatile                                    \
        ("      ps_muls1        %0, %1, %2\n"           \
         : "=f"(out)                                    \
         : "f"(mul0), "f"(mul1)                         \
        );                                              \
        out;                                            \
})

#define paired_nmadd(mul0, mul1, add) ({                \
        double out;                                     \
        asm volatile                                    \
        ("      ps_nmadd        %0, %1, %2, %3\n"       \
         : "=f"(out)                                    \
         : "f"(mul0), "f"(mul1), "f"(add)               \
        );                                              \
        out;                                            \
})

#define paired_nmsub(mul0, mul1, sub) ({                \
        double out;                                     \
        asm volatile                                    \
        ("      ps_nmsub        %0, %1, %2, %3\n"       \
         : "=f"(out)                                    \
         : "f"(mul0), "f"(mul1), "f"(sub)               \
        );                                              \
        out;                                            \
})

#define paired_merge00(pair0, pair1) ({                 \
        double out;                                     \
        asm volatile                                    \
        ("      ps_merge00      %0, %1, %2\n"           \
         : "=f"(out)                                    \
         : "f"(pair0), "f"(pair1)                       \
        );                                              \
        out;                                            \
})

#define paired_merge01(pair0, pair1) ({                 \
        double out;                                     \
        asm volatile                                    \
        ("      ps_merge01      %0, %1, %2\n"           \
         : "=f"(out)                                    \
         : "f"(pair0), "f"(pair1)                       \
        );                                              \
        out;                                            \
})

#define paired_merge10(pair0, pair1) ({                 \
        double out;                                     \
        asm volatile                                    \
        ("      ps_merge10      %0, %1, %2\n"           \
         : "=f"(out)                                    \
         : "f"(pair0), "f"(pair1)                       \
        );                                              \
        out;                                            \
})

#define paired_merge11(pair0, pair1) ({                 \
        double out;                                     \
        asm volatile                                    \
        ("      ps_merge11      %0, %1, %2\n"           \
         : "=f"(out)                                    \
         : "f"(pair0), "f"(pair1)                       \
        );                                              \
        out;                                            \
})

#define paired_select(sel, pos, neg) ({                 \
        double out;                                     \
        asm volatile                                    \
        ("      ps_sel          %0, %1, %2, %3\n"       \
         : "=f"(out)                                    \
         : "f"(sel), "f"(pos), "f"(neg)                 \
        );                                              \
        out;                                            \
})

#define paired_sum0(pair0, pair1, pair2) ({             \
        double out;                                     \
        asm volatile                                    \
        ("      ps_sum0         %0, %1, %2, %3\n"       \
         : "=f"(out)                                    \
         : "f"(pair0), "f"(pair2), "f"(pair1)           \
        );                                              \
        out;                                            \
})

#define paired_sum1(pair0, pair1, pair2) ({             \
        double out;                                     \
        asm volatile                                    \
        ("      ps_sum1         %0, %1, %2, %3\n"       \
         : "=f"(out)                                    \
         : "f"(pair0), "f"(pair2), "f"(pair1)           \
        );                                              \
        out;                                            \
})

#endif