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