src/gallium/drivers/llvmpipe/lp_bld_test.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_format.h"
  39
  40 #include "lp_bld.h"
  41
  42
  43 struct pixel_test_case
  44 {
  45    enum pipe_format format;
  46    uint32_t packed;
  47    double unpacked[4];
  48 };
  49
  50
  51 struct pixel_test_case test_cases[] =
  52 {
  53    {PIPE_FORMAT_R5G6B5_UNORM,   0x0000, {0.0, 0.0, 0.0, 1.0}},
  54    {PIPE_FORMAT_R5G6B5_UNORM,   0x001f, {0.0, 0.0, 1.0, 1.0}},
  55    {PIPE_FORMAT_R5G6B5_UNORM,   0x07e0, {0.0, 1.0, 0.0, 1.0}},
  56    {PIPE_FORMAT_R5G6B5_UNORM,   0xf800, {1.0, 0.0, 0.0, 1.0}},
  57    {PIPE_FORMAT_R5G6B5_UNORM,   0xffff, {1.0, 1.0, 1.0, 1.0}},
  58
  59    {PIPE_FORMAT_A1R5G5B5_UNORM, 0x0000, {0.0, 0.0, 0.0, 0.0}},
  60    {PIPE_FORMAT_A1R5G5B5_UNORM, 0x001f, {0.0, 0.0, 1.0, 0.0}},
  61    {PIPE_FORMAT_A1R5G5B5_UNORM, 0x03e0, {0.0, 1.0, 0.0, 0.0}},
  62    {PIPE_FORMAT_A1R5G5B5_UNORM, 0x7c00, {1.0, 0.0, 0.0, 0.0}},
  63    {PIPE_FORMAT_A1R5G5B5_UNORM, 0x8000, {0.0, 0.0, 0.0, 1.0}},
  64    {PIPE_FORMAT_A1R5G5B5_UNORM, 0xffff, {1.0, 1.0, 1.0, 1.0}},
  65
  66    {PIPE_FORMAT_A8R8G8B8_UNORM, 0x00000000, {0.0, 0.0, 0.0, 0.0}},
  67    {PIPE_FORMAT_A8R8G8B8_UNORM, 0x000000ff, {0.0, 0.0, 1.0, 0.0}},
  68    {PIPE_FORMAT_A8R8G8B8_UNORM, 0x0000ff00, {0.0, 1.0, 0.0, 0.0}},
  69    {PIPE_FORMAT_A8R8G8B8_UNORM, 0x00ff0000, {1.0, 0.0, 0.0, 0.0}},
  70    {PIPE_FORMAT_A8R8G8B8_UNORM, 0xff000000, {0.0, 0.0, 0.0, 1.0}},
  71    {PIPE_FORMAT_A8R8G8B8_UNORM, 0xffffffff, {1.0, 1.0, 1.0, 1.0}},
  72
  73 #if 0
  74    {PIPE_FORMAT_R8G8B8A8_UNORM, 0x00000000, {0.0, 0.0, 0.0, 0.0}},
  75    {PIPE_FORMAT_R8G8B8A8_UNORM, 0x000000ff, {0.0, 0.0, 0.0, 1.0}},
  76    {PIPE_FORMAT_R8G8B8A8_UNORM, 0x0000ff00, {0.0, 0.0, 1.0, 0.0}},
  77    {PIPE_FORMAT_R8G8B8A8_UNORM, 0x00ff0000, {0.0, 1.0, 0.0, 0.0}},
  78    {PIPE_FORMAT_R8G8B8A8_UNORM, 0xff000000, {1.0, 0.0, 0.0, 0.0}},
  79    {PIPE_FORMAT_R8G8B8A8_UNORM, 0xffffffff, {1.0, 1.0, 1.0, 1.0}},
  80 #endif
  81
  82    {PIPE_FORMAT_B8G8R8A8_UNORM, 0x00000000, {0.0, 0.0, 0.0, 0.0}},
  83    {PIPE_FORMAT_B8G8R8A8_UNORM, 0x000000ff, {0.0, 0.0, 0.0, 1.0}},
  84    {PIPE_FORMAT_B8G8R8A8_UNORM, 0x0000ff00, {1.0, 0.0, 0.0, 0.0}},
  85    {PIPE_FORMAT_B8G8R8A8_UNORM, 0x00ff0000, {0.0, 1.0, 0.0, 0.0}},
  86    {PIPE_FORMAT_B8G8R8A8_UNORM, 0xff000000, {0.0, 0.0, 1.0, 0.0}},
  87    {PIPE_FORMAT_B8G8R8A8_UNORM, 0xffffffff, {1.0, 1.0, 1.0, 1.0}},
  88 };
  89
  90
  91 static LLVMValueRef
  92 add_load_rgba_test(LLVMModuleRef module,
  93                    enum pipe_format format)
  94 {
  95    LLVMTypeRef args[] = {
  96       LLVMPointerType(LLVMInt8Type(), 0),
  97       LLVMPointerType(LLVMVectorType(LLVMFloatType(), 4), 0)
  98    };
  99    LLVMValueRef func = LLVMAddFunction(module, "load", LLVMFunctionType(LLVMVoidType(), args, 2, 0));
 100    LLVMSetFunctionCallConv(func, LLVMCCallConv);
 101    LLVMValueRef ptr = LLVMGetParam(func, 0);
 102    LLVMValueRef rgba_ptr = LLVMGetParam(func, 1);
 103
 104    LLVMBasicBlockRef block = LLVMAppendBasicBlock(func, "entry");
 105    LLVMBuilderRef builder = LLVMCreateBuilder();
 106    LLVMPositionBuilderAtEnd(builder, block);
 107
 108    LLVMValueRef rgba;
 109
 110    struct lp_build_loop_state loop;
 111
 112    lp_build_loop_begin(builder, LLVMConstInt(LLVMInt32Type(), 1, 0), &loop);
 113
 114    rgba = lp_build_load_rgba(builder, format, ptr);
 115    LLVMBuildStore(builder, rgba, rgba_ptr);
 116
 117    lp_build_loop_end(builder, LLVMConstInt(LLVMInt32Type(), 4, 0), NULL, &loop);
 118
 119    LLVMBuildRetVoid(builder);
 120
 121    LLVMDisposeBuilder(builder);
 122    return func;
 123 }
 124
 125
 126 static LLVMValueRef
 127 add_store_rgba_test(LLVMModuleRef module,
 128                     enum pipe_format format)
 129 {
 130    LLVMTypeRef args[] = {
 131       LLVMPointerType(LLVMInt8Type(), 0),
 132       LLVMPointerType(LLVMVectorType(LLVMFloatType(), 4), 0)
 133    };
 134    LLVMValueRef func = LLVMAddFunction(module, "store", LLVMFunctionType(LLVMVoidType(), args, 2, 0));
 135    LLVMSetFunctionCallConv(func, LLVMCCallConv);
 136    LLVMValueRef ptr = LLVMGetParam(func, 0);
 137    LLVMValueRef rgba_ptr = LLVMGetParam(func, 1);
 138
 139    LLVMBasicBlockRef block = LLVMAppendBasicBlock(func, "entry");
 140    LLVMBuilderRef builder = LLVMCreateBuilder();
 141    LLVMPositionBuilderAtEnd(builder, block);
 142
 143    LLVMValueRef rgba;
 144
 145    rgba = LLVMBuildLoad(builder, rgba_ptr, "");
 146
 147    lp_build_store_rgba(builder, format, ptr, rgba);
 148
 149    LLVMBuildRetVoid(builder);
 150
 151    LLVMDisposeBuilder(builder);
 152    return func;
 153 }
 154
 155
 156 static boolean
 157 test_format(const struct pixel_test_case *test)
 158 {
 159    char *error = NULL;
 160    const struct util_format_description *desc;
 161
 162    desc = util_format_description(test->format);
 163    fprintf(stderr, "%s\n", desc->name);
 164
 165    LLVMModuleRef module = LLVMModuleCreateWithName("test");
 166
 167    LLVMValueRef load = add_load_rgba_test(module, test->format);
 168    LLVMValueRef store = add_store_rgba_test(module, test->format);
 169
 170    LLVMVerifyModule(module, LLVMAbortProcessAction, &error);
 171    LLVMDisposeMessage(error);
 172
 173    LLVMExecutionEngineRef engine;
 174    LLVMModuleProviderRef provider = LLVMCreateModuleProviderForExistingModule(module);
 175    error = NULL;
 176    LLVMCreateJITCompiler(&engine, provider, 1, &error);
 177    if (error) {
 178       fprintf(stderr, "%s\n", error);
 179       LLVMDisposeMessage(error);
 180       abort();
 181    }
 182
 183    LLVMPassManagerRef pass = LLVMCreatePassManager();
 184 #if 0
 185    LLVMAddTargetData(LLVMGetExecutionEngineTargetData(engine), pass);
 186    /* These are the passes currently listed in llvm-c/Transforms/Scalar.h,
 187     * but there are more on SVN. */
 188    LLVMAddConstantPropagationPass(pass);
 189    LLVMAddInstructionCombiningPass(pass);
 190    LLVMAddPromoteMemoryToRegisterPass(pass);
 191    LLVMAddDemoteMemoryToRegisterPass(pass);
 192    LLVMAddGVNPass(pass);
 193    LLVMAddCFGSimplificationPass(pass);
 194    LLVMRunPassManager(pass, module);
 195    LLVMDumpModule(module);
 196 #endif
 197
 198
 199    float unpacked[4] = {0, 0, 0, 0};
 200    unsigned packed = 0;
 201
 202    {
 203       typedef void (*load_ptr_t)(const void *, float *);
 204       load_ptr_t load_ptr = (load_ptr_t)LLVMGetPointerToGlobal(engine, load);
 205
 206       load_ptr(&test->packed, unpacked);
 207
 208    }
 209
 210
 211    {
 212       typedef void (*store_ptr_t)(void *, const float *);
 213       store_ptr_t store_ptr = (store_ptr_t)LLVMGetPointerToGlobal(engine, store);
 214
 215       store_ptr(&packed, unpacked);
 216
 217    }
 218
 219    boolean success = TRUE;
 220    unsigned i;
 221    if(test->packed != packed)
 222       success = FALSE;
 223    for(i = 0; i < 4; ++i)
 224       if(test->unpacked[i] != unpacked[i])
 225          success = FALSE;
 226
 227    if (!success) {
 228       printf("FAILED\n");
 229       printf("  Packed: %08x\n", test->packed);
 230       printf("          %08x\n", packed);
 231       printf("  Unpacked: %f %f %f %f\n", unpacked[0], unpacked[1], unpacked[2], unpacked[3]);
 232       printf("            %f %f %f %f\n", test->unpacked[0], test->unpacked[1], test->unpacked[2], test->unpacked[3]);
 233       LLVMDumpModule(module);
 234    }
 235
 236    LLVMDisposePassManager(pass);
 237    LLVMDisposeExecutionEngine(engine);
 238    //LLVMDisposeModule(module);
 239
 240    return success;
 241 }
 242
 243
 244 int main(int argc, char **argv)
 245 {
 246    unsigned i;
 247    int ret;
 248
 249    for (i = 0; i < sizeof(test_cases)/sizeof(test_cases[0]); ++i)
 250       if(!test_format(&test_cases[i]))
 251         ret = 1;
 252
 253    return ret;
 254 }