apps/codecs/lib/asm_arm.h

   1 /********************************************************************
   2  *                                                                  *
   3  * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE.   *
   4  *                                                                  *
   5  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
   6  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
   7  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
   8  *                                                                  *
   9  * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002    *
  10  * BY THE Xiph.Org FOUNDATION http://www.xiph.org/                  *
  11  *                                                                  *
  12  ********************************************************************
  13
  14  function: arm7 and later wide math functions
  15
  16  ********************************************************************/
  17 #ifdef CPU_ARM
  18
  19 #if !defined(_V_WIDE_MATH) && !defined(_LOW_ACCURACY_)
  20 #define _V_WIDE_MATH
  21
  22 static inline int32_t MULT32(int32_t x, int32_t y) {
  23   int lo,hi;
  24   asm volatile("smull\t%0, %1, %2, %3"
  25                : "=&r"(lo),"=&r"(hi)
  26                : "%r"(x),"r"(y) );
  27   return(hi);
  28 }
  29
  30 static inline int32_t MULT31(int32_t x, int32_t y) {
  31   return MULT32(x,y)<<1;
  32 }
  33
  34 static inline int32_t MULT31_SHIFT15(int32_t x, int32_t y) {
  35   int lo,hi;
  36   asm volatile("smull   %0, %1, %2, %3\n\t"
  37                "movs    %0, %0, lsr #15\n\t"
  38                "adc     %1, %0, %1, lsl #17\n\t"
  39                : "=&r"(lo),"=&r"(hi)
  40                : "%r"(x),"r"(y)
  41                : "cc" );
  42   return(hi);
  43 }
  44
  45 #define XPROD32(a, b, t, v, x, y) \
  46 { \
  47   long l; \
  48   asm(  "smull  %0, %1, %4, %6\n\t" \
  49         "rsb    %3, %4, #0\n\t" \
  50         "smlal  %0, %1, %5, %7\n\t" \
  51         "smull  %0, %2, %5, %6\n\t" \
  52         "smlal  %0, %2, %3, %7" \
  53         : "=&r" (l), "=&r" (x), "=&r" (y), "=r" ((a)) \
  54         : "3" ((a)), "r" ((b)), "r" ((t)), "r" ((v)) ); \
  55 }
  56
  57 static inline void XPROD31(int32_t  a, int32_t  b,
  58                            int32_t  t, int32_t  v,
  59                            int32_t *x, int32_t *y)
  60 {
  61   int x1, y1, l;
  62   asm(  "smull  %0, %1, %4, %6\n\t"
  63         "rsb    %3, %4, #0\n\t"
  64         "smlal  %0, %1, %5, %7\n\t"
  65         "smull  %0, %2, %5, %6\n\t"
  66         "smlal  %0, %2, %3, %7"
  67         : "=&r" (l), "=&r" (x1), "=&r" (y1), "=r" (a)
  68         : "3" (a), "r" (b), "r" (t), "r" (v) );
  69   *x = x1 << 1;
  70   *y = y1 << 1;
  71 }
  72
  73 static inline void XNPROD31(int32_t  a, int32_t  b,
  74                             int32_t  t, int32_t  v,
  75                             int32_t *x, int32_t *y)
  76 {
  77   int x1, y1, l;
  78   asm(  "smull  %0, %1, %3, %5\n\t"
  79         "rsb    %2, %4, #0\n\t"
  80         "smlal  %0, %1, %2, %6\n\t"
  81         "smull  %0, %2, %4, %5\n\t"
  82         "smlal  %0, %2, %3, %6"
  83         : "=&r" (l), "=&r" (x1), "=&r" (y1)
  84         : "r" (a), "r" (b), "r" (t), "r" (v) );
  85   *x = x1 << 1;
  86   *y = y1 << 1;
  87 }
  88
  89 #ifndef _V_VECT_OPS
  90 #define _V_VECT_OPS
  91
  92 /* asm versions of vector operations for block.c, window.c */
  93 static inline
  94 void vect_add(int32_t *x, int32_t *y, int n)
  95 {
  96   while (n>=4) {
  97     asm volatile ("ldmia %[x], {r0, r1, r2, r3};"
  98                   "ldmia %[y]!, {r4, r5, r6, r7};"
  99                   "add r0, r0, r4;"
 100                   "add r1, r1, r5;"
 101                   "add r2, r2, r6;"
 102                   "add r3, r3, r7;"
 103                   "stmia %[x]!, {r0, r1, r2, r3};"
 104                   : [x] "+r" (x), [y] "+r" (y)
 105                   : : "r0", "r1", "r2", "r3",
 106                   "r4", "r5", "r6", "r7",
 107                   "memory");
 108     n -= 4;
 109   }
 110   /* add final elements */
 111   while (n>0) {
 112     *x++ += *y++;
 113     n--;
 114   }
 115 }
 116
 117 static inline
 118 void vect_copy(int32_t *x, int32_t *y, int n)
 119 {
 120   while (n>=4) {
 121     asm volatile ("ldmia %[y]!, {r0, r1, r2, r3};"
 122                   "stmia %[x]!, {r0, r1, r2, r3};"
 123                   : [x] "+r" (x), [y] "+r" (y)
 124                   : : "r0", "r1", "r2", "r3",
 125                   "memory");
 126     n -= 4;
 127   }
 128   /* copy final elements */
 129   while (n>0) {
 130     *x++ = *y++;
 131     n--;
 132   }
 133 }
 134
 135 static inline
 136 void vect_mult_fw(int32_t *data, int32_t *window, int n)
 137 {
 138   while (n>=4) {
 139     asm volatile ("ldmia %[d], {r0, r1, r2, r3};"
 140                   "ldmia %[w]!, {r4, r5, r6, r7};"
 141                   "smull r8, r9, r0, r4;"
 142                   "mov   r0, r9, lsl #1;"
 143                   "smull r8, r9, r1, r5;"
 144                   "mov   r1, r9, lsl #1;"
 145                   "smull r8, r9, r2, r6;"
 146                   "mov   r2, r9, lsl #1;"
 147                   "smull r8, r9, r3, r7;"
 148                   "mov   r3, r9, lsl #1;"
 149                   "stmia %[d]!, {r0, r1, r2, r3};"
 150                   : [d] "+r" (data), [w] "+r" (window)
 151                   : : "r0", "r1", "r2", "r3",
 152                   "r4", "r5", "r6", "r7", "r8", "r9",
 153                   "memory" );
 154     n -= 4;
 155   }
 156   while(n>0) {
 157     *data = MULT31(*data, *window);
 158     data++;
 159     window++;
 160     n--;
 161   }
 162 }
 163
 164 static inline
 165 void vect_mult_bw(int32_t *data, int32_t *window, int n)
 166 {
 167   while (n>=4) {
 168     asm volatile ("ldmia %[d], {r0, r1, r2, r3};"
 169                   "ldmda %[w]!, {r4, r5, r6, r7};"
 170                   "smull r8, r9, r0, r7;"
 171                   "mov   r0, r9, lsl #1;"
 172                   "smull r8, r9, r1, r6;"
 173                   "mov   r1, r9, lsl #1;"
 174                   "smull r8, r9, r2, r5;"
 175                   "mov   r2, r9, lsl #1;"
 176                   "smull r8, r9, r3, r4;"
 177                   "mov   r3, r9, lsl #1;"
 178                   "stmia %[d]!, {r0, r1, r2, r3};"
 179                   : [d] "+r" (data), [w] "+r" (window)
 180                   : : "r0", "r1", "r2", "r3",
 181                   "r4", "r5", "r6", "r7", "r8", "r9",
 182                   "memory" );
 183     n -= 4;
 184   }
 185   while(n>0) {
 186     *data = MULT31(*data, *window);
 187     data++;
 188     window--;
 189     n--;
 190   }
 191 }
 192
 193 #endif
 194
 195 #endif
 196
 197 #ifndef _V_CLIP_MATH
 198 #define _V_CLIP_MATH
 199
 200 static inline int32_t CLIP_TO_15(int32_t x) {
 201   int tmp;
 202   asm volatile("subs    %1, %0, #32768\n\t"
 203                "movpl   %0, #0x7f00\n\t"
 204                "orrpl   %0, %0, #0xff\n"
 205                "adds    %1, %0, #32768\n\t"
 206                "movmi   %0, #0x8000"
 207                : "+r"(x),"=r"(tmp)
 208                :
 209                : "cc");
 210   return(x);
 211 }
 212
 213 #endif
 214
 215 #ifndef _V_LSP_MATH_ASM
 216 #define _V_LSP_MATH_ASM
 217
 218
 219
 220 #endif
 221 #endif
 222