lib/librte_eal/common/include/generic/rte_vect.h

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright 2016 6WIND S.A.
   5  *
   6  *   Redistribution and use in source and binary forms, with or without
   7  *   modification, are permitted provided that the following conditions
   8  *   are met:
   9  *
  10  *     * Redistributions of source code must retain the above copyright
  11  *       notice, this list of conditions and the following disclaimer.
  12  *     * Redistributions in binary form must reproduce the above copyright
  13  *       notice, this list of conditions and the following disclaimer in
  14  *       the documentation and/or other materials provided with the
  15  *       distribution.
  16  *     * Neither the name of 6WIND S.A. nor the names of its
  17  *       contributors may be used to endorse or promote products derived
  18  *       from this software without specific prior written permission.
  19  *
  20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #ifndef _RTE_VECT_H_
  34 #define _RTE_VECT_H_
  35
  36 /**
  37  * @file
  38  * SIMD vector types
  39  *
  40  * This file defines types to use vector instructions with generic C code.
  41  */
  42
  43 #include <stdint.h>
  44
  45 /* Unsigned vector types */
  46
  47 /**
  48  * 64 bits vector size to use with unsigned 8 bits elements.
  49  *
  50  * a = (rte_v64u8_t){ a0, a1, a2, a3, a4, a5, a6, a7 }
  51  */
  52 typedef uint8_t rte_v64u8_t __attribute__((vector_size(8), aligned(8)));
  53
  54 /**
  55  * 64 bits vector size to use with unsigned 16 bits elements.
  56  *
  57  * a = (rte_v64u16_t){ a0, a1, a2, a3 }
  58  */
  59 typedef uint16_t rte_v64u16_t __attribute__((vector_size(8), aligned(8)));
  60
  61 /**
  62  * 64 bits vector size to use with unsigned 32 bits elements.
  63  *
  64  * a = (rte_v64u32_t){ a0, a1 }
  65  */
  66 typedef uint32_t rte_v64u32_t __attribute__((vector_size(8), aligned(8)));
  67
  68 /**
  69  * 128 bits vector size to use with unsigned 8 bits elements.
  70  *
  71  * a = (rte_v128u8_t){ a00, a01, a02, a03, a04, a05, a06, a07,
  72  *                     a08, a09, a10, a11, a12, a13, a14, a15 }
  73  */
  74 typedef uint8_t rte_v128u8_t __attribute__((vector_size(16), aligned(16)));
  75
  76 /**
  77  * 128 bits vector size to use with unsigned 16 bits elements.
  78  *
  79  * a = (rte_v128u16_t){ a0, a1, a2, a3, a4, a5, a6, a7 }
  80  */
  81 typedef uint16_t rte_v128u16_t __attribute__((vector_size(16), aligned(16)));
  82
  83 /**
  84  * 128 bits vector size to use with unsigned 32 bits elements.
  85  *
  86  * a = (rte_v128u32_t){ a0, a1, a2, a3, a4 }
  87  */
  88 typedef uint32_t rte_v128u32_t __attribute__((vector_size(16), aligned(16)));
  89
  90 /**
  91  * 128 bits vector size to use with unsigned 64 bits elements.
  92  *
  93  * a = (rte_v128u64_t){ a0, a1 }
  94  */
  95 typedef uint64_t rte_v128u64_t __attribute__((vector_size(16), aligned(16)));
  96
  97 /**
  98  * 256 bits vector size to use with unsigned 8 bits elements.
  99  *
 100  * a = (rte_v256u8_t){ a00, a01, a02, a03, a04, a05, a06, a07,
 101  *                     a08, a09, a10, a11, a12, a13, a14, a15,
 102  *                     a16, a17, a18, a19, a20, a21, a22, a23,
 103  *                     a24, a25, a26, a27, a28, a29, a30, a31 }
 104  */
 105 typedef uint8_t rte_v256u8_t __attribute__((vector_size(32), aligned(32)));
 106
 107 /**
 108  * 256 bits vector size to use with unsigned 16 bits elements.
 109  *
 110  * a = (rte_v256u16_t){ a00, a01, a02, a03, a04, a05, a06, a07,
 111  *                      a08, a09, a10, a11, a12, a13, a14, a15 }
 112  */
 113 typedef uint16_t rte_v256u16_t __attribute__((vector_size(32), aligned(32)));
 114
 115 /**
 116  * 256 bits vector size to use with unsigned 32 bits elements.
 117  *
 118  * a = (rte_v256u32_t){ a0, a1, a2, a3, a4, a5, a6, a7 }
 119  */
 120 typedef uint32_t rte_v256u32_t __attribute__((vector_size(32), aligned(32)));
 121
 122 /**
 123  * 256 bits vector size to use with unsigned 64 bits elements.
 124  *
 125  * a = (rte_v256u64_t){ a0, a1, a2, a3 }
 126  */
 127 typedef uint64_t rte_v256u64_t __attribute__((vector_size(32), aligned(32)));
 128
 129
 130 /* Signed vector types */
 131
 132 /**
 133  * 64 bits vector size to use with 8 bits elements.
 134  *
 135  * a = (rte_v64s8_t){ a0, a1, a2, a3, a4, a5, a6, a7 }
 136  */
 137 typedef int8_t rte_v64s8_t __attribute__((vector_size(8), aligned(8)));
 138
 139 /**
 140  * 64 bits vector size to use with 16 bits elements.
 141  *
 142  * a = (rte_v64s16_t){ a0, a1, a2, a3 }
 143  */
 144 typedef int16_t rte_v64s16_t __attribute__((vector_size(8), aligned(8)));
 145
 146 /**
 147  * 64 bits vector size to use with 32 bits elements.
 148  *
 149  * a = (rte_v64s32_t){ a0, a1 }
 150  */
 151 typedef int32_t rte_v64s32_t __attribute__((vector_size(8), aligned(8)));
 152
 153 /**
 154  * 128 bits vector size to use with 8 bits elements.
 155  *
 156  * a = (rte_v128s8_t){ a00, a01, a02, a03, a04, a05, a06, a07,
 157  *                     a08, a09, a10, a11, a12, a13, a14, a15 }
 158  */
 159 typedef int8_t rte_v128s8_t __attribute__((vector_size(16), aligned(16)));
 160
 161 /**
 162  * 128 bits vector size to use with 16 bits elements.
 163  *
 164  * a = (rte_v128s16_t){ a0, a1, a2, a3, a4, a5, a6, a7 }
 165  */
 166 typedef int16_t rte_v128s16_t __attribute__((vector_size(16), aligned(16)));
 167
 168 /**
 169  * 128 bits vector size to use with 32 bits elements.
 170  *
 171  * a = (rte_v128s32_t){ a0, a1, a2, a3 }
 172  */
 173 typedef int32_t rte_v128s32_t __attribute__((vector_size(16), aligned(16)));
 174
 175 /**
 176  * 128 bits vector size to use with 64 bits elements.
 177  *
 178  * a = (rte_v128s64_t){ a1, a2 }
 179  */
 180 typedef int64_t rte_v128s64_t __attribute__((vector_size(16), aligned(16)));
 181
 182 /**
 183  * 256 bits vector size to use with 8 bits elements.
 184  *
 185  * a = (rte_v256s8_t){ a00, a01, a02, a03, a04, a05, a06, a07,
 186  *                     a08, a09, a10, a11, a12, a13, a14, a15,
 187  *                     a16, a17, a18, a19, a20, a21, a22, a23,
 188  *                     a24, a25, a26, a27, a28, a29, a30, a31 }
 189  */
 190 typedef int8_t rte_v256s8_t __attribute__((vector_size(32), aligned(32)));
 191
 192 /**
 193  * 256 bits vector size to use with 16 bits elements.
 194  *
 195  * a = (rte_v256s16_t){ a00, a01, a02, a03, a04, a05, a06, a07,
 196  *                      a08, a09, a10, a11, a12, a13, a14, a15 }
 197  */
 198 typedef int16_t rte_v256s16_t __attribute__((vector_size(32), aligned(32)));
 199
 200 /**
 201  * 256 bits vector size to use with 32 bits elements.
 202  *
 203  * a = (rte_v256s32_t){ a0, a1, a2, a3, a4, a5, a6, a7 }
 204  */
 205 typedef int32_t rte_v256s32_t __attribute__((vector_size(32), aligned(32)));
 206
 207 /**
 208  * 256 bits vector size to use with 64 bits elements.
 209  *
 210  * a = (rte_v256s64_t){ a0, a1, a2, a3 }
 211  */
 212 typedef int64_t rte_v256s64_t __attribute__((vector_size(32), aligned(32)));
 213
 214 #endif /* _RTE_VECT_H_ */