src/gallium/auxiliary/draw/draw_llvm_translate.c

   1 #include "draw_private.h"
   2 #include "draw_context.h"
   3
   4 #include "draw_llvm.h"
   5
   6 #include "gallivm/lp_bld_arit.h"
   7 #include "gallivm/lp_bld_struct.h"
   8 #include "gallivm/lp_bld_format.h"
   9 #include "gallivm/lp_bld_debug.h"
  10 #include "gallivm/lp_bld_type.h"
  11
  12 #include "util/u_memory.h"
  13 #include "util/u_format.h"
  14 #include "pipe/p_state.h"
  15
  16
  17 #define DRAW_DBG 0
  18
  19 static  LLVMValueRef
  20 from_64_float(LLVMBuilderRef builder, LLVMValueRef val)
  21 {
  22    LLVMValueRef bc = LLVMBuildBitCast(builder, val,
  23                                       LLVMPointerType(LLVMDoubleType(), 0) , "");
  24    LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
  25    return LLVMBuildFPTrunc(builder, l, LLVMFloatType(), "");
  26 }
  27
  28 static LLVMValueRef
  29 from_32_float(LLVMBuilderRef builder, LLVMValueRef val)
  30 {
  31    LLVMValueRef bc = LLVMBuildBitCast(builder, val,
  32                                       LLVMPointerType(LLVMFloatType(), 0) , "");
  33    return LLVMBuildLoad(builder, bc, "");
  34 }
  35
  36 static INLINE LLVMValueRef
  37 from_8_uscaled(LLVMBuilderRef builder, LLVMValueRef val)
  38 {
  39    LLVMValueRef l = LLVMBuildLoad(builder, val, "");
  40    return LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
  41 }
  42
  43 static INLINE LLVMValueRef
  44 from_16_uscaled(LLVMBuilderRef builder, LLVMValueRef val)
  45 {
  46    LLVMValueRef bc = LLVMBuildBitCast(builder, val,
  47                                       LLVMPointerType(LLVMIntType(16), 0) , "");
  48    LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
  49    return LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
  50 }
  51
  52 static INLINE LLVMValueRef
  53 from_32_uscaled(LLVMBuilderRef builder, LLVMValueRef val)
  54 {
  55    LLVMValueRef bc = LLVMBuildBitCast(builder, val,
  56                                       LLVMPointerType(LLVMIntType(32), 0) , "");
  57    LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
  58    return LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
  59 }
  60
  61 static INLINE LLVMValueRef
  62 from_8_sscaled(LLVMBuilderRef builder, LLVMValueRef val)
  63 {
  64    LLVMValueRef l = LLVMBuildLoad(builder, val, "");
  65    return LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
  66 }
  67
  68 static INLINE LLVMValueRef
  69 from_16_sscaled(LLVMBuilderRef builder, LLVMValueRef val)
  70 {
  71    LLVMValueRef bc = LLVMBuildBitCast(builder, val,
  72                                       LLVMPointerType(LLVMIntType(16), 0) , "");
  73    LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
  74    return LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
  75 }
  76
  77 static INLINE LLVMValueRef
  78 from_32_sscaled(LLVMBuilderRef builder, LLVMValueRef val)
  79 {
  80    LLVMValueRef bc = LLVMBuildBitCast(builder, val,
  81                                       LLVMPointerType(LLVMIntType(32), 0) , "");
  82    LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
  83    return LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
  84 }
  85
  86
  87 static INLINE LLVMValueRef
  88 from_8_unorm(LLVMBuilderRef builder, LLVMValueRef val)
  89 {
  90    LLVMValueRef l = LLVMBuildLoad(builder, val, "");
  91    LLVMValueRef uscaled = LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
  92    return LLVMBuildFDiv(builder, uscaled,
  93                         LLVMConstReal(LLVMFloatType(), 255.), "");
  94 }
  95
  96 static INLINE LLVMValueRef
  97 from_16_unorm(LLVMBuilderRef builder, LLVMValueRef val)
  98 {
  99    LLVMValueRef bc = LLVMBuildBitCast(builder, val,
 100                                       LLVMPointerType(LLVMIntType(16), 0) , "");
 101    LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
 102    LLVMValueRef uscaled = LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
 103    return LLVMBuildFDiv(builder, uscaled,
 104                         LLVMConstReal(LLVMFloatType(), 65535.), "");
 105 }
 106
 107 static INLINE LLVMValueRef
 108 from_32_unorm(LLVMBuilderRef builder, LLVMValueRef val)
 109 {
 110    LLVMValueRef bc = LLVMBuildBitCast(builder, val,
 111                                       LLVMPointerType(LLVMIntType(32), 0) , "");
 112    LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
 113    LLVMValueRef uscaled = LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
 114
 115    return LLVMBuildFDiv(builder, uscaled,
 116                         LLVMConstReal(LLVMFloatType(), 4294967295.), "");
 117 }
 118
 119 static INLINE LLVMValueRef
 120 from_8_snorm(LLVMBuilderRef builder, LLVMValueRef val)
 121 {
 122    LLVMValueRef l = LLVMBuildLoad(builder, val, "");
 123    LLVMValueRef uscaled = LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
 124    return LLVMBuildFDiv(builder, uscaled,
 125                         LLVMConstReal(LLVMFloatType(), 127.0), "");
 126 }
 127
 128 static INLINE LLVMValueRef
 129 from_16_snorm(LLVMBuilderRef builder, LLVMValueRef val)
 130 {
 131    LLVMValueRef bc = LLVMBuildBitCast(builder, val,
 132                                       LLVMPointerType(LLVMIntType(16), 0) , "");
 133    LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
 134    LLVMValueRef uscaled = LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
 135    return LLVMBuildFDiv(builder, uscaled,
 136                         LLVMConstReal(LLVMFloatType(), 32767.0f), "");
 137 }
 138
 139 static INLINE LLVMValueRef
 140 from_32_snorm(LLVMBuilderRef builder, LLVMValueRef val)
 141 {
 142    LLVMValueRef bc = LLVMBuildBitCast(builder, val,
 143                                       LLVMPointerType(LLVMIntType(32), 0) , "");
 144    LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
 145    LLVMValueRef uscaled = LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
 146
 147    return LLVMBuildFDiv(builder, uscaled,
 148                         LLVMConstReal(LLVMFloatType(), 2147483647.0), "");
 149 }
 150
 151 static INLINE LLVMValueRef
 152 from_32_fixed(LLVMBuilderRef builder, LLVMValueRef val)
 153 {
 154    LLVMValueRef bc = LLVMBuildBitCast(builder, val,
 155                                       LLVMPointerType(LLVMIntType(32), 0) , "");
 156    LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
 157    LLVMValueRef uscaled = LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
 158
 159    return LLVMBuildFDiv(builder, uscaled,
 160                         LLVMConstReal(LLVMFloatType(), 65536.0), "");
 161 }
 162
 163 static LLVMValueRef
 164 to_64_float(LLVMBuilderRef builder, LLVMValueRef fp)
 165 {
 166    LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
 167    return LLVMBuildFPExt(builder, l, LLVMDoubleType(), "");
 168 }
 169
 170 static LLVMValueRef
 171 to_32_float(LLVMBuilderRef builder, LLVMValueRef fp)
 172 {
 173    return LLVMBuildLoad(builder, fp, "");
 174 }
 175
 176 static INLINE LLVMValueRef
 177 to_8_uscaled(LLVMBuilderRef builder, LLVMValueRef fp)
 178 {
 179    LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
 180    return LLVMBuildFPToUI(builder, l, LLVMIntType(8), "");
 181 }
 182
 183 static INLINE LLVMValueRef
 184 to_16_uscaled(LLVMBuilderRef builder, LLVMValueRef fp)
 185 {
 186    LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
 187    return LLVMBuildFPToUI(builder, l, LLVMIntType(16), "");
 188 }
 189
 190 static INLINE LLVMValueRef
 191 to_32_uscaled(LLVMBuilderRef builder, LLVMValueRef fp)
 192 {
 193    LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
 194    return LLVMBuildFPToUI(builder, l, LLVMIntType(32), "");
 195 }
 196
 197 static INLINE LLVMValueRef
 198 to_8_sscaled(LLVMBuilderRef builder, LLVMValueRef fp)
 199 {
 200    LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
 201    return LLVMBuildFPToSI(builder, l, LLVMIntType(8), "");
 202 }
 203
 204 static INLINE LLVMValueRef
 205 to_16_sscaled(LLVMBuilderRef builder, LLVMValueRef fp)
 206 {
 207    LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
 208    return LLVMBuildFPToSI(builder, l, LLVMIntType(16), "");
 209 }
 210
 211 static INLINE LLVMValueRef
 212 to_32_sscaled(LLVMBuilderRef builder, LLVMValueRef fp)
 213 {
 214    LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
 215    return LLVMBuildFPToSI(builder, l, LLVMIntType(32), "");
 216 }
 217
 218 static INLINE LLVMValueRef
 219 to_8_unorm(LLVMBuilderRef builder, LLVMValueRef fp)
 220 {
 221    LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
 222    LLVMValueRef uscaled = LLVMBuildFPToUI(builder, l, LLVMIntType(8), "");
 223    return LLVMBuildFMul(builder, uscaled,
 224                         LLVMConstReal(LLVMFloatType(), 255.), "");
 225 }
 226
 227 static INLINE LLVMValueRef
 228 to_16_unorm(LLVMBuilderRef builder, LLVMValueRef fp)
 229 {
 230    LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
 231    LLVMValueRef uscaled = LLVMBuildFPToUI(builder, l, LLVMIntType(32), "");
 232    return LLVMBuildFMul(builder, uscaled,
 233                         LLVMConstReal(LLVMFloatType(), 65535.), "");
 234 }
 235
 236 static INLINE LLVMValueRef
 237 to_32_unorm(LLVMBuilderRef builder, LLVMValueRef fp)
 238 {
 239    LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
 240    LLVMValueRef uscaled = LLVMBuildFPToUI(builder, l, LLVMIntType(32), "");
 241
 242    return LLVMBuildFMul(builder, uscaled,
 243                         LLVMConstReal(LLVMFloatType(), 4294967295.), "");
 244 }
 245
 246 static INLINE LLVMValueRef
 247 to_8_snorm(LLVMBuilderRef builder, LLVMValueRef val)
 248 {
 249    LLVMValueRef l = LLVMBuildLoad(builder, val, "");
 250    LLVMValueRef uscaled = LLVMBuildFPToSI(builder, l, LLVMIntType(8), "");
 251    return LLVMBuildFMul(builder, uscaled,
 252                         LLVMConstReal(LLVMFloatType(), 127.0), "");
 253 }
 254
 255 static INLINE LLVMValueRef
 256 to_16_snorm(LLVMBuilderRef builder, LLVMValueRef fp)
 257 {
 258    LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
 259    LLVMValueRef uscaled = LLVMBuildFPToSI(builder, l, LLVMIntType(16), "");
 260    return LLVMBuildFMul(builder, uscaled,
 261                         LLVMConstReal(LLVMFloatType(), 32767.0f), "");
 262 }
 263
 264 static INLINE LLVMValueRef
 265 to_32_snorm(LLVMBuilderRef builder, LLVMValueRef fp)
 266 {
 267    LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
 268    LLVMValueRef uscaled = LLVMBuildFPToSI(builder, l, LLVMIntType(32), "");
 269
 270    return LLVMBuildFMul(builder, uscaled,
 271                         LLVMConstReal(LLVMFloatType(), 2147483647.0), "");
 272 }
 273
 274 static INLINE LLVMValueRef
 275 to_32_fixed(LLVMBuilderRef builder, LLVMValueRef fp)
 276 {
 277    LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
 278    LLVMValueRef uscaled = LLVMBuildFPToSI(builder, l, LLVMIntType(32), "");
 279
 280    return LLVMBuildFMul(builder, uscaled,
 281                         LLVMConstReal(LLVMFloatType(), 65536.0), "");
 282 }
 283
 284 typedef LLVMValueRef (*from_func)(LLVMBuilderRef, LLVMValueRef);
 285 typedef  LLVMValueRef (*to_func)(LLVMBuilderRef, LLVMValueRef);
 286
 287 /* so that underneath can avoid function calls which are prohibited
 288  * for static initialization we need this conversion */
 289 enum ll_type {
 290    LL_Double,
 291    LL_Float,
 292    LL_Int32,
 293    LL_Int16,
 294    LL_Int8
 295 };
 296
 297 static INLINE LLVMTypeRef
 298 ll_type_to_llvm(enum ll_type type)
 299 {
 300    switch (type) {
 301    case LL_Double:
 302       return LLVMDoubleType();
 303    case LL_Float:
 304       return LLVMFloatType();
 305    case LL_Int32:
 306       return LLVMInt32Type();
 307    case LL_Int16:
 308       return LLVMIntType(16);
 309    case LL_Int8:
 310       return LLVMIntType(8);
 311    }
 312    return LLVMIntType(8);
 313 }
 314
 315 static INLINE int
 316 ll_type_size(enum ll_type type)
 317 {
 318    switch (type) {
 319    case LL_Double:
 320       return 8;
 321    case LL_Float:
 322       return 4;
 323    case LL_Int32:
 324       return 4;
 325    case LL_Int16:
 326       return 2;
 327    case LL_Int8:
 328       return 1;
 329    }
 330    return 1;
 331 }
 332
 333 struct draw_llvm_translate {
 334    int format;
 335    from_func from;
 336    to_func to;
 337    enum ll_type type;
 338    int num_components;
 339 } translates[] =
 340 {
 341    {PIPE_FORMAT_R64_FLOAT,          from_64_float, to_64_float, LL_Double, 1},
 342    {PIPE_FORMAT_R64G64_FLOAT,       from_64_float, to_64_float, LL_Double, 2},
 343    {PIPE_FORMAT_R64G64B64_FLOAT,    from_64_float, to_64_float, LL_Double, 3},
 344    {PIPE_FORMAT_R64G64B64A64_FLOAT, from_64_float, to_64_float, LL_Double, 4},
 345    {PIPE_FORMAT_R32_FLOAT,          from_32_float, to_32_float, LL_Float, 1},
 346    {PIPE_FORMAT_R32G32_FLOAT,       from_32_float, to_32_float, LL_Float, 2},
 347    {PIPE_FORMAT_R32G32B32_FLOAT,    from_32_float, to_32_float, LL_Float, 3},
 348    {PIPE_FORMAT_R32G32B32A32_FLOAT, from_32_float, to_32_float, LL_Float, 4},
 349
 350    {PIPE_FORMAT_R32_UNORM,          from_32_unorm, to_32_unorm, LL_Int32, 1},
 351    {PIPE_FORMAT_R32G32_UNORM,       from_32_unorm, to_32_unorm, LL_Int32, 2},
 352    {PIPE_FORMAT_R32G32B32_UNORM,    from_32_unorm, to_32_unorm, LL_Int32, 3},
 353    {PIPE_FORMAT_R32G32B32A32_UNORM, from_32_unorm, to_32_unorm, LL_Int32, 4},
 354
 355    {PIPE_FORMAT_R32_USCALED,          from_32_uscaled, to_32_uscaled, LL_Int32, 1},
 356    {PIPE_FORMAT_R32G32_USCALED,       from_32_uscaled, to_32_uscaled, LL_Int32, 2},
 357    {PIPE_FORMAT_R32G32B32_USCALED,    from_32_uscaled, to_32_uscaled, LL_Int32, 3},
 358    {PIPE_FORMAT_R32G32B32A32_USCALED, from_32_uscaled, to_32_uscaled, LL_Int32, 4},
 359
 360    {PIPE_FORMAT_R32_SNORM,          from_32_snorm, to_32_snorm, LL_Int32, 1},
 361    {PIPE_FORMAT_R32G32_SNORM,       from_32_snorm, to_32_snorm, LL_Int32, 2},
 362    {PIPE_FORMAT_R32G32B32_SNORM,    from_32_snorm, to_32_snorm, LL_Int32, 3},
 363    {PIPE_FORMAT_R32G32B32A32_SNORM, from_32_snorm, to_32_snorm, LL_Int32, 4},
 364
 365    {PIPE_FORMAT_R32_SSCALED,          from_32_sscaled, to_32_sscaled, LL_Int32, 1},
 366    {PIPE_FORMAT_R32G32_SSCALED,       from_32_sscaled, to_32_sscaled, LL_Int32, 2},
 367    {PIPE_FORMAT_R32G32B32_SSCALED,    from_32_sscaled, to_32_sscaled, LL_Int32, 3},
 368    {PIPE_FORMAT_R32G32B32A32_SSCALED, from_32_sscaled, to_32_sscaled, LL_Int32, 4},
 369
 370    {PIPE_FORMAT_R16_UNORM,          from_16_unorm, to_16_unorm, LL_Int16, 1},
 371    {PIPE_FORMAT_R16G16_UNORM,       from_16_unorm, to_16_unorm, LL_Int16, 2},
 372    {PIPE_FORMAT_R16G16B16_UNORM,    from_16_unorm, to_16_unorm, LL_Int16, 3},
 373    {PIPE_FORMAT_R16G16B16A16_UNORM, from_16_unorm, to_16_unorm, LL_Int16, 4},
 374
 375    {PIPE_FORMAT_R16_USCALED,          from_16_uscaled, to_16_uscaled, LL_Int16, 1},
 376    {PIPE_FORMAT_R16G16_USCALED,       from_16_uscaled, to_16_uscaled, LL_Int16, 2},
 377    {PIPE_FORMAT_R16G16B16_USCALED,    from_16_uscaled, to_16_uscaled, LL_Int16, 3},
 378    {PIPE_FORMAT_R16G16B16A16_USCALED, from_16_uscaled, to_16_uscaled, LL_Int16, 4},
 379
 380    {PIPE_FORMAT_R16_SNORM,          from_16_snorm, to_16_snorm, LL_Int16, 1},
 381    {PIPE_FORMAT_R16G16_SNORM,       from_16_snorm, to_16_snorm, LL_Int16, 2},
 382    {PIPE_FORMAT_R16G16B16_SNORM,    from_16_snorm, to_16_snorm, LL_Int16, 3},
 383    {PIPE_FORMAT_R16G16B16A16_SNORM, from_16_snorm, to_16_snorm, LL_Int16, 4},
 384
 385    {PIPE_FORMAT_R16_SSCALED,          from_16_sscaled, to_16_sscaled, LL_Int16, 1},
 386    {PIPE_FORMAT_R16G16_SSCALED,       from_16_sscaled, to_16_sscaled, LL_Int16, 2},
 387    {PIPE_FORMAT_R16G16B16_SSCALED,    from_16_sscaled, to_16_sscaled, LL_Int16, 3},
 388    {PIPE_FORMAT_R16G16B16A16_SSCALED, from_16_sscaled, to_16_sscaled, LL_Int16, 4},
 389
 390    {PIPE_FORMAT_R8_UNORM,       from_8_unorm, to_8_unorm, LL_Int8, 1},
 391    {PIPE_FORMAT_R8G8_UNORM,     from_8_unorm, to_8_unorm, LL_Int8, 2},
 392    {PIPE_FORMAT_R8G8B8_UNORM,   from_8_unorm, to_8_unorm, LL_Int8, 3},
 393    {PIPE_FORMAT_R8G8B8A8_UNORM, from_8_unorm, to_8_unorm, LL_Int8, 4},
 394
 395    {PIPE_FORMAT_R8_USCALED,       from_8_uscaled, to_8_uscaled, LL_Int8, 1},
 396    {PIPE_FORMAT_R8G8_USCALED,     from_8_uscaled, to_8_uscaled, LL_Int8, 2},
 397    {PIPE_FORMAT_R8G8B8_USCALED,   from_8_uscaled, to_8_uscaled, LL_Int8, 3},
 398    {PIPE_FORMAT_R8G8B8A8_USCALED, from_8_uscaled, to_8_uscaled, LL_Int8, 4},
 399
 400    {PIPE_FORMAT_R8_SNORM,       from_8_snorm, to_8_snorm, LL_Int8, 1},
 401    {PIPE_FORMAT_R8G8_SNORM,     from_8_snorm, to_8_snorm, LL_Int8, 2},
 402    {PIPE_FORMAT_R8G8B8_SNORM,   from_8_snorm, to_8_snorm, LL_Int8, 3},
 403    {PIPE_FORMAT_R8G8B8A8_SNORM, from_8_snorm, to_8_snorm, LL_Int8, 4},
 404
 405    {PIPE_FORMAT_R8_SSCALED,       from_8_sscaled, to_8_sscaled, LL_Int8, 1},
 406    {PIPE_FORMAT_R8G8_SSCALED,     from_8_sscaled, to_8_sscaled, LL_Int8, 2},
 407    {PIPE_FORMAT_R8G8B8_SSCALED,   from_8_sscaled, to_8_sscaled, LL_Int8, 3},
 408    {PIPE_FORMAT_R8G8B8A8_SSCALED, from_8_sscaled, to_8_sscaled, LL_Int8, 4},
 409
 410    {PIPE_FORMAT_R32_FIXED,          from_32_fixed, to_32_fixed, LL_Int32, 1},
 411    {PIPE_FORMAT_R32G32_FIXED,       from_32_fixed, to_32_fixed, LL_Int32, 2},
 412    {PIPE_FORMAT_R32G32B32_FIXED,    from_32_fixed, to_32_fixed, LL_Int32, 3},
 413    {PIPE_FORMAT_R32G32B32A32_FIXED, from_32_fixed, to_32_fixed, LL_Int32, 4},
 414 };
 415
 416
 417 static LLVMValueRef
 418 fetch(LLVMBuilderRef builder,
 419       LLVMValueRef ptr, int val_size, int nr_components,
 420       from_func func)
 421 {
 422    int i;
 423    int offset = 0;
 424    LLVMValueRef res = LLVMConstNull(
 425       LLVMVectorType(LLVMFloatType(), 4));
 426    LLVMValueRef defaults[4];
 427
 428    defaults[0] = LLVMConstReal(LLVMFloatType(), 0);
 429    defaults[1] = LLVMConstReal(LLVMFloatType(), 0);
 430    defaults[2] = LLVMConstReal(LLVMFloatType(), 0);
 431    defaults[3] = LLVMConstReal(LLVMFloatType(), 1);
 432
 433    for (i = 0; i < nr_components; ++i) {
 434       LLVMValueRef src_index = LLVMConstInt(LLVMInt32Type(), offset, 0);
 435       LLVMValueRef dst_index = LLVMConstInt(LLVMInt32Type(), i, 0);
 436       LLVMValueRef src_tmp;
 437       LLVMValueRef component;
 438
 439       src_tmp = LLVMBuildGEP(builder, ptr, &src_index, 1, "src_tmp");
 440
 441       /* convert src_tmp to float */
 442       component = func(builder, src_tmp);
 443
 444       /* vec.comp = component */
 445       res = LLVMBuildInsertElement(builder,
 446                                    res,
 447                                    component,
 448                                    dst_index, "");
 449       offset += val_size;
 450    }
 451    for (; i < 4; ++i) {
 452       LLVMValueRef dst_index = LLVMConstInt(LLVMInt32Type(), i, 0);
 453       res = LLVMBuildInsertElement(builder,
 454                                    res,
 455                                    defaults[i],
 456                                    dst_index, "");
 457    }
 458    return res;
 459 }
 460
 461
 462 LLVMValueRef
 463 draw_llvm_translate_from(LLVMBuilderRef builder,
 464                          LLVMValueRef vbuffer,
 465                          enum pipe_format from_format)
 466 {
 467    const struct util_format_description *format_desc;
 468    LLVMValueRef zero;
 469    int i;
 470    struct lp_type type = lp_float32_vec4_type();
 471
 472    /*
 473     * The above can only cope with straight arrays: no bitfields,
 474     * swizzles, or half floats.
 475     */
 476
 477    for (i = 0; i < Elements(translates); ++i) {
 478       if (translates[i].format == from_format) {
 479          /*LLVMTypeRef type = ll_type_to_llvm(translates[i].type);*/
 480          return fetch(builder,
 481                       vbuffer,
 482                       ll_type_size(translates[i].type),
 483                       translates[i].num_components,
 484                       translates[i].from);
 485       }
 486    }
 487
 488
 489    /*
 490     * This doesn't handle anything bigger than 32bits, or half floats
 491     * yet.
 492     *
 493     * TODO: unify all this code into lp_build_fetch_rgba_aos().
 494     */
 495
 496    format_desc = util_format_description(from_format);
 497    zero = LLVMConstNull(LLVMInt32Type());
 498    return lp_build_fetch_rgba_aos(builder, format_desc, type, vbuffer, zero, zero, zero);
 499 }