src/gallium/drivers/llvmpipe/lp_test_format.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2009 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31
  32 #include <llvm-c/Core.h>
  33 #include <llvm-c/Analysis.h>
  34 #include <llvm-c/ExecutionEngine.h>
  35 #include <llvm-c/Target.h>
  36 #include <llvm-c/Transforms/Scalar.h>
  37
  38 #include "util/u_cpu_detect.h"
  39 #include "util/u_format.h"
  40
  41 #include "lp_bld_format.h"
  42
  43
  44 struct pixel_test_case
  45 {
  46    enum pipe_format format;
  47    uint32_t packed;
  48    double unpacked[4];
  49 };
  50
  51
  52 struct pixel_test_case test_cases[] =
  53 {
  54    {PIPE_FORMAT_R5G6B5_UNORM,   0x0000, {0.0, 0.0, 0.0, 1.0}},
  55    {PIPE_FORMAT_R5G6B5_UNORM,   0x001f, {0.0, 0.0, 1.0, 1.0}},
  56    {PIPE_FORMAT_R5G6B5_UNORM,   0x07e0, {0.0, 1.0, 0.0, 1.0}},
  57    {PIPE_FORMAT_R5G6B5_UNORM,   0xf800, {1.0, 0.0, 0.0, 1.0}},
  58    {PIPE_FORMAT_R5G6B5_UNORM,   0xffff, {1.0, 1.0, 1.0, 1.0}},
  59
  60    {PIPE_FORMAT_A1R5G5B5_UNORM, 0x0000, {0.0, 0.0, 0.0, 0.0}},
  61    {PIPE_FORMAT_A1R5G5B5_UNORM, 0x001f, {0.0, 0.0, 1.0, 0.0}},
  62    {PIPE_FORMAT_A1R5G5B5_UNORM, 0x03e0, {0.0, 1.0, 0.0, 0.0}},
  63    {PIPE_FORMAT_A1R5G5B5_UNORM, 0x7c00, {1.0, 0.0, 0.0, 0.0}},
  64    {PIPE_FORMAT_A1R5G5B5_UNORM, 0x8000, {0.0, 0.0, 0.0, 1.0}},
  65    {PIPE_FORMAT_A1R5G5B5_UNORM, 0xffff, {1.0, 1.0, 1.0, 1.0}},
  66
  67    {PIPE_FORMAT_A8R8G8B8_UNORM, 0x00000000, {0.0, 0.0, 0.0, 0.0}},
  68    {PIPE_FORMAT_A8R8G8B8_UNORM, 0x000000ff, {0.0, 0.0, 1.0, 0.0}},
  69    {PIPE_FORMAT_A8R8G8B8_UNORM, 0x0000ff00, {0.0, 1.0, 0.0, 0.0}},
  70    {PIPE_FORMAT_A8R8G8B8_UNORM, 0x00ff0000, {1.0, 0.0, 0.0, 0.0}},
  71    {PIPE_FORMAT_A8R8G8B8_UNORM, 0xff000000, {0.0, 0.0, 0.0, 1.0}},
  72    {PIPE_FORMAT_A8R8G8B8_UNORM, 0xffffffff, {1.0, 1.0, 1.0, 1.0}},
  73
  74 #if 0
  75    {PIPE_FORMAT_R8G8B8A8_UNORM, 0x00000000, {0.0, 0.0, 0.0, 0.0}},
  76    {PIPE_FORMAT_R8G8B8A8_UNORM, 0x000000ff, {0.0, 0.0, 0.0, 1.0}},
  77    {PIPE_FORMAT_R8G8B8A8_UNORM, 0x0000ff00, {0.0, 0.0, 1.0, 0.0}},
  78    {PIPE_FORMAT_R8G8B8A8_UNORM, 0x00ff0000, {0.0, 1.0, 0.0, 0.0}},
  79    {PIPE_FORMAT_R8G8B8A8_UNORM, 0xff000000, {1.0, 0.0, 0.0, 0.0}},
  80    {PIPE_FORMAT_R8G8B8A8_UNORM, 0xffffffff, {1.0, 1.0, 1.0, 1.0}},
  81 #endif
  82
  83    {PIPE_FORMAT_B8G8R8A8_UNORM, 0x00000000, {0.0, 0.0, 0.0, 0.0}},
  84    {PIPE_FORMAT_B8G8R8A8_UNORM, 0x000000ff, {0.0, 0.0, 0.0, 1.0}},
  85    {PIPE_FORMAT_B8G8R8A8_UNORM, 0x0000ff00, {1.0, 0.0, 0.0, 0.0}},
  86    {PIPE_FORMAT_B8G8R8A8_UNORM, 0x00ff0000, {0.0, 1.0, 0.0, 0.0}},
  87    {PIPE_FORMAT_B8G8R8A8_UNORM, 0xff000000, {0.0, 0.0, 1.0, 0.0}},
  88    {PIPE_FORMAT_B8G8R8A8_UNORM, 0xffffffff, {1.0, 1.0, 1.0, 1.0}},
  89 };
  90
  91
  92 typedef void (*load_ptr_t)(const uint32_t packed, float *);
  93
  94
  95 static LLVMValueRef
  96 add_load_rgba_test(LLVMModuleRef module,
  97                    enum pipe_format format)
  98 {
  99    const struct util_format_description *desc;
 100    LLVMTypeRef args[2];
 101    LLVMValueRef func;
 102    LLVMValueRef packed;
 103    LLVMValueRef rgba_ptr;
 104    LLVMBasicBlockRef block;
 105    LLVMBuilderRef builder;
 106    LLVMValueRef rgba;
 107
 108    desc = util_format_description(format);
 109
 110    args[0] = LLVMInt32Type();
 111    args[1] = LLVMPointerType(LLVMVectorType(LLVMFloatType(), 4), 0);
 112
 113    func = LLVMAddFunction(module, "load", LLVMFunctionType(LLVMVoidType(), args, 2, 0));
 114    LLVMSetFunctionCallConv(func, LLVMCCallConv);
 115    packed = LLVMGetParam(func, 0);
 116    rgba_ptr = LLVMGetParam(func, 1);
 117
 118    block = LLVMAppendBasicBlock(func, "entry");
 119    builder = LLVMCreateBuilder();
 120    LLVMPositionBuilderAtEnd(builder, block);
 121
 122    if(desc->block.bits < 32)
 123       packed = LLVMBuildTrunc(builder, packed, LLVMIntType(desc->block.bits), "");
 124
 125    rgba = lp_build_unpack_rgba_aos(builder, desc, packed);
 126
 127    LLVMBuildStore(builder, rgba, rgba_ptr);
 128
 129    LLVMBuildRetVoid(builder);
 130
 131    LLVMDisposeBuilder(builder);
 132    return func;
 133 }
 134
 135
 136 typedef void (*store_ptr_t)(uint32_t *, const float *);
 137
 138
 139 static LLVMValueRef
 140 add_store_rgba_test(LLVMModuleRef module,
 141                     enum pipe_format format)
 142 {
 143    const struct util_format_description *desc;
 144    LLVMTypeRef args[2];
 145    LLVMValueRef func;
 146    LLVMValueRef packed_ptr;
 147    LLVMValueRef rgba_ptr;
 148    LLVMBasicBlockRef block;
 149    LLVMBuilderRef builder;
 150    LLVMValueRef rgba;
 151    LLVMValueRef packed;
 152
 153    desc = util_format_description(format);
 154
 155    args[0] = LLVMPointerType(LLVMInt32Type(), 0);
 156    args[1] = LLVMPointerType(LLVMVectorType(LLVMFloatType(), 4), 0);
 157
 158    func = LLVMAddFunction(module, "store", LLVMFunctionType(LLVMVoidType(), args, 2, 0));
 159    LLVMSetFunctionCallConv(func, LLVMCCallConv);
 160    packed_ptr = LLVMGetParam(func, 0);
 161    rgba_ptr = LLVMGetParam(func, 1);
 162
 163    block = LLVMAppendBasicBlock(func, "entry");
 164    builder = LLVMCreateBuilder();
 165    LLVMPositionBuilderAtEnd(builder, block);
 166
 167    rgba = LLVMBuildLoad(builder, rgba_ptr, "");
 168
 169    packed = lp_build_pack_rgba_aos(builder, desc, rgba);
 170
 171    if(desc->block.bits < 32)
 172       packed = LLVMBuildZExt(builder, packed, LLVMInt32Type(), "");
 173
 174    LLVMBuildStore(builder, packed, packed_ptr);
 175
 176    LLVMBuildRetVoid(builder);
 177
 178    LLVMDisposeBuilder(builder);
 179    return func;
 180 }
 181
 182
 183 static boolean
 184 test_format(const struct pixel_test_case *test)
 185 {
 186    LLVMModuleRef module = NULL;
 187    LLVMValueRef load = NULL;
 188    LLVMValueRef store = NULL;
 189    LLVMExecutionEngineRef engine = NULL;
 190    LLVMModuleProviderRef provider = NULL;
 191    LLVMPassManagerRef pass = NULL;
 192    char *error = NULL;
 193    const struct util_format_description *desc;
 194    load_ptr_t load_ptr;
 195    store_ptr_t store_ptr;
 196    float unpacked[4];
 197    unsigned packed;
 198    boolean success;
 199    unsigned i;
 200
 201    desc = util_format_description(test->format);
 202    fprintf(stderr, "%s\n", desc->name);
 203
 204    module = LLVMModuleCreateWithName("test");
 205
 206    load = add_load_rgba_test(module, test->format);
 207    store = add_store_rgba_test(module, test->format);
 208
 209    if(LLVMVerifyModule(module, LLVMPrintMessageAction, &error)) {
 210       LLVMDumpModule(module);
 211       abort();
 212    }
 213    LLVMDisposeMessage(error);
 214
 215    provider = LLVMCreateModuleProviderForExistingModule(module);
 216    if (LLVMCreateJITCompiler(&engine, provider, 1, &error)) {
 217       fprintf(stderr, "%s\n", error);
 218       LLVMDisposeMessage(error);
 219       abort();
 220    }
 221
 222 #if 0
 223    pass = LLVMCreatePassManager();
 224    LLVMAddTargetData(LLVMGetExecutionEngineTargetData(engine), pass);
 225    /* These are the passes currently listed in llvm-c/Transforms/Scalar.h,
 226     * but there are more on SVN. */
 227    LLVMAddConstantPropagationPass(pass);
 228    LLVMAddInstructionCombiningPass(pass);
 229    LLVMAddPromoteMemoryToRegisterPass(pass);
 230    LLVMAddGVNPass(pass);
 231    LLVMAddCFGSimplificationPass(pass);
 232    LLVMRunPassManager(pass, module);
 233 #else
 234    (void)pass;
 235 #endif
 236
 237    load_ptr  = (load_ptr_t) LLVMGetPointerToGlobal(engine, load);
 238    store_ptr = (store_ptr_t)LLVMGetPointerToGlobal(engine, store);
 239
 240    memset(unpacked, 0, sizeof unpacked);
 241    packed = 0;
 242
 243    load_ptr(test->packed, unpacked);
 244    store_ptr(&packed, unpacked);
 245
 246    success = TRUE;
 247    if(test->packed != packed)
 248       success = FALSE;
 249    for(i = 0; i < 4; ++i)
 250       if(test->unpacked[i] != unpacked[i])
 251          success = FALSE;
 252
 253    if (!success) {
 254       printf("FAILED\n");
 255       printf("  Packed: %08x\n", test->packed);
 256       printf("          %08x\n", packed);
 257       printf("  Unpacked: %f %f %f %f\n", unpacked[0], unpacked[1], unpacked[2], unpacked[3]);
 258       printf("            %f %f %f %f\n", test->unpacked[0], test->unpacked[1], test->unpacked[2], test->unpacked[3]);
 259       LLVMDumpModule(module);
 260    }
 261
 262    LLVMFreeMachineCodeForFunction(engine, store);
 263    LLVMFreeMachineCodeForFunction(engine, load);
 264
 265    LLVMDisposeExecutionEngine(engine);
 266    if(pass)
 267       LLVMDisposePassManager(pass);
 268
 269    return success;
 270 }
 271
 272
 273 int main(int argc, char **argv)
 274 {
 275    unsigned i;
 276    int ret;
 277
 278 #ifdef LLVM_NATIVE_ARCH
 279    LLVMLinkInJIT();
 280    LLVMInitializeNativeTarget();
 281 #endif
 282
 283    util_cpu_detect();
 284
 285    for (i = 0; i < sizeof(test_cases)/sizeof(test_cases[0]); ++i)
 286       if(!test_format(&test_cases[i]))
 287         ret = 1;
 288
 289    return ret;
 290 }