src/gallium/drivers/llvmpipe/lp_jit.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  * @file
  30  * C - JIT interfaces
  31  *
  32  * @author Jose Fonseca <jfonseca@vmware.com>
  33  */
  34
  35 #include <llvm/Config/llvm-config.h>
  36
  37 #include "util/u_memory.h"
  38 #include "gallivm/lp_bld_init.h"
  39 #include "gallivm/lp_bld_debug.h"
  40 #include "gallivm/lp_bld_format.h"
  41 #include "lp_context.h"
  42 #include "lp_jit.h"
  43
  44 static LLVMTypeRef
  45 create_jit_texture_type(struct gallivm_state *gallivm)
  46 {
  47    LLVMContextRef lc = gallivm->context;
  48    LLVMTypeRef texture_type;
  49    LLVMTypeRef elem_types[LP_JIT_TEXTURE_NUM_FIELDS];
  50
  51    /* struct lp_jit_texture */
  52    elem_types[LP_JIT_TEXTURE_WIDTH]  =
  53    elem_types[LP_JIT_TEXTURE_HEIGHT] =
  54    elem_types[LP_JIT_TEXTURE_DEPTH] =
  55    elem_types[LP_JIT_TEXTURE_FIRST_LEVEL] =
  56    elem_types[LP_JIT_TEXTURE_LAST_LEVEL] = LLVMInt32TypeInContext(lc);
  57    elem_types[LP_JIT_TEXTURE_BASE] = LLVMPointerType(LLVMInt8TypeInContext(lc), 0);
  58    elem_types[LP_JIT_TEXTURE_ROW_STRIDE] =
  59    elem_types[LP_JIT_TEXTURE_IMG_STRIDE] =
  60    elem_types[LP_JIT_TEXTURE_MIP_OFFSETS] =
  61       LLVMArrayType(LLVMInt32TypeInContext(lc), LP_MAX_TEXTURE_LEVELS);
  62
  63    texture_type = LLVMStructTypeInContext(lc, elem_types,
  64                                           ARRAY_SIZE(elem_types), 0);
  65
  66    LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, width,
  67                           gallivm->target, texture_type,
  68                           LP_JIT_TEXTURE_WIDTH);
  69    LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, height,
  70                           gallivm->target, texture_type,
  71                           LP_JIT_TEXTURE_HEIGHT);
  72    LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, depth,
  73                           gallivm->target, texture_type,
  74                           LP_JIT_TEXTURE_DEPTH);
  75    LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, base,
  76                           gallivm->target, texture_type,
  77                           LP_JIT_TEXTURE_BASE);
  78    LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, row_stride,
  79                           gallivm->target, texture_type,
  80                           LP_JIT_TEXTURE_ROW_STRIDE);
  81    LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, img_stride,
  82                           gallivm->target, texture_type,
  83                           LP_JIT_TEXTURE_IMG_STRIDE);
  84    LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, first_level,
  85                           gallivm->target, texture_type,
  86                           LP_JIT_TEXTURE_FIRST_LEVEL);
  87    LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, last_level,
  88                           gallivm->target, texture_type,
  89                           LP_JIT_TEXTURE_LAST_LEVEL);
  90    LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, mip_offsets,
  91                           gallivm->target, texture_type,
  92                           LP_JIT_TEXTURE_MIP_OFFSETS);
  93    LP_CHECK_STRUCT_SIZE(struct lp_jit_texture,
  94                         gallivm->target, texture_type);
  95    return texture_type;
  96 }
  97
  98 static LLVMTypeRef
  99 create_jit_sampler_type(struct gallivm_state *gallivm)
 100 {
 101    LLVMContextRef lc = gallivm->context;
 102    LLVMTypeRef sampler_type;
 103    LLVMTypeRef elem_types[LP_JIT_SAMPLER_NUM_FIELDS];
 104    elem_types[LP_JIT_SAMPLER_MIN_LOD] =
 105    elem_types[LP_JIT_SAMPLER_MAX_LOD] =
 106    elem_types[LP_JIT_SAMPLER_LOD_BIAS] = LLVMFloatTypeInContext(lc);
 107    elem_types[LP_JIT_SAMPLER_BORDER_COLOR] =
 108       LLVMArrayType(LLVMFloatTypeInContext(lc), 4);
 109
 110    sampler_type = LLVMStructTypeInContext(lc, elem_types,
 111                                           ARRAY_SIZE(elem_types), 0);
 112
 113    LP_CHECK_MEMBER_OFFSET(struct lp_jit_sampler, min_lod,
 114                           gallivm->target, sampler_type,
 115                           LP_JIT_SAMPLER_MIN_LOD);
 116    LP_CHECK_MEMBER_OFFSET(struct lp_jit_sampler, max_lod,
 117                           gallivm->target, sampler_type,
 118                           LP_JIT_SAMPLER_MAX_LOD);
 119    LP_CHECK_MEMBER_OFFSET(struct lp_jit_sampler, lod_bias,
 120                           gallivm->target, sampler_type,
 121                           LP_JIT_SAMPLER_LOD_BIAS);
 122    LP_CHECK_MEMBER_OFFSET(struct lp_jit_sampler, border_color,
 123                           gallivm->target, sampler_type,
 124                           LP_JIT_SAMPLER_BORDER_COLOR);
 125    LP_CHECK_STRUCT_SIZE(struct lp_jit_sampler,
 126                         gallivm->target, sampler_type);
 127    return sampler_type;
 128 }
 129
 130 static LLVMTypeRef
 131 create_jit_image_type(struct gallivm_state *gallivm)
 132 {
 133    LLVMContextRef lc = gallivm->context;
 134    LLVMTypeRef image_type;
 135    LLVMTypeRef elem_types[LP_JIT_IMAGE_NUM_FIELDS];
 136    elem_types[LP_JIT_IMAGE_WIDTH] =
 137    elem_types[LP_JIT_IMAGE_HEIGHT] =
 138    elem_types[LP_JIT_IMAGE_DEPTH] = LLVMInt32TypeInContext(lc);
 139    elem_types[LP_JIT_IMAGE_BASE] = LLVMPointerType(LLVMInt8TypeInContext(lc), 0);
 140    elem_types[LP_JIT_IMAGE_ROW_STRIDE] =
 141    elem_types[LP_JIT_IMAGE_IMG_STRIDE] = LLVMInt32TypeInContext(lc);
 142
 143    image_type = LLVMStructTypeInContext(lc, elem_types,
 144                                         ARRAY_SIZE(elem_types), 0);
 145    LP_CHECK_MEMBER_OFFSET(struct lp_jit_image, width,
 146                           gallivm->target, image_type,
 147                           LP_JIT_IMAGE_WIDTH);
 148    LP_CHECK_MEMBER_OFFSET(struct lp_jit_image, height,
 149                           gallivm->target, image_type,
 150                           LP_JIT_IMAGE_HEIGHT);
 151    LP_CHECK_MEMBER_OFFSET(struct lp_jit_image, depth,
 152                           gallivm->target, image_type,
 153                           LP_JIT_IMAGE_DEPTH);
 154    LP_CHECK_MEMBER_OFFSET(struct lp_jit_image, base,
 155                           gallivm->target, image_type,
 156                           LP_JIT_IMAGE_BASE);
 157    LP_CHECK_MEMBER_OFFSET(struct lp_jit_image, row_stride,
 158                           gallivm->target, image_type,
 159                           LP_JIT_IMAGE_ROW_STRIDE);
 160    LP_CHECK_MEMBER_OFFSET(struct lp_jit_image, img_stride,
 161                           gallivm->target, image_type,
 162                           LP_JIT_IMAGE_IMG_STRIDE);
 163    return image_type;
 164 }
 165
 166 static void
 167 lp_jit_create_types(struct lp_fragment_shader_variant *lp)
 168 {
 169    struct gallivm_state *gallivm = lp->gallivm;
 170    LLVMContextRef lc = gallivm->context;
 171    LLVMTypeRef viewport_type, texture_type, sampler_type, image_type;
 172
 173    /* struct lp_jit_viewport */
 174    {
 175       LLVMTypeRef elem_types[LP_JIT_VIEWPORT_NUM_FIELDS];
 176
 177       elem_types[LP_JIT_VIEWPORT_MIN_DEPTH] =
 178       elem_types[LP_JIT_VIEWPORT_MAX_DEPTH] = LLVMFloatTypeInContext(lc);
 179
 180       viewport_type = LLVMStructTypeInContext(lc, elem_types,
 181                                               ARRAY_SIZE(elem_types), 0);
 182
 183       LP_CHECK_MEMBER_OFFSET(struct lp_jit_viewport, min_depth,
 184                              gallivm->target, viewport_type,
 185                              LP_JIT_VIEWPORT_MIN_DEPTH);
 186       LP_CHECK_MEMBER_OFFSET(struct lp_jit_viewport, max_depth,
 187                              gallivm->target, viewport_type,
 188                              LP_JIT_VIEWPORT_MAX_DEPTH);
 189       LP_CHECK_STRUCT_SIZE(struct lp_jit_viewport,
 190                            gallivm->target, viewport_type);
 191    }
 192
 193    texture_type = create_jit_texture_type(gallivm);
 194    sampler_type = create_jit_sampler_type(gallivm);
 195    image_type = create_jit_image_type(gallivm);
 196
 197    /* struct lp_jit_context */
 198    {
 199       LLVMTypeRef elem_types[LP_JIT_CTX_COUNT];
 200       LLVMTypeRef context_type;
 201
 202       elem_types[LP_JIT_CTX_CONSTANTS] =
 203          LLVMArrayType(LLVMPointerType(LLVMFloatTypeInContext(lc), 0), LP_MAX_TGSI_CONST_BUFFERS);
 204       elem_types[LP_JIT_CTX_NUM_CONSTANTS] =
 205             LLVMArrayType(LLVMInt32TypeInContext(lc), LP_MAX_TGSI_CONST_BUFFERS);
 206       elem_types[LP_JIT_CTX_TEXTURES] = LLVMArrayType(texture_type,
 207                                                       PIPE_MAX_SHADER_SAMPLER_VIEWS);
 208       elem_types[LP_JIT_CTX_SAMPLERS] = LLVMArrayType(sampler_type,
 209                                                       PIPE_MAX_SAMPLERS);
 210       elem_types[LP_JIT_CTX_IMAGES] = LLVMArrayType(image_type,
 211                                                     PIPE_MAX_SHADER_IMAGES);
 212       elem_types[LP_JIT_CTX_ALPHA_REF] = LLVMFloatTypeInContext(lc);
 213       elem_types[LP_JIT_CTX_STENCIL_REF_FRONT] =
 214       elem_types[LP_JIT_CTX_STENCIL_REF_BACK] = LLVMInt32TypeInContext(lc);
 215       elem_types[LP_JIT_CTX_U8_BLEND_COLOR] = LLVMPointerType(LLVMInt8TypeInContext(lc), 0);
 216       elem_types[LP_JIT_CTX_F_BLEND_COLOR] = LLVMPointerType(LLVMFloatTypeInContext(lc), 0);
 217       elem_types[LP_JIT_CTX_VIEWPORTS] = LLVMPointerType(viewport_type, 0);
 218       elem_types[LP_JIT_CTX_SSBOS] =
 219          LLVMArrayType(LLVMPointerType(LLVMInt32TypeInContext(lc), 0), LP_MAX_TGSI_SHADER_BUFFERS);
 220       elem_types[LP_JIT_CTX_NUM_SSBOS] =
 221             LLVMArrayType(LLVMInt32TypeInContext(lc), LP_MAX_TGSI_SHADER_BUFFERS);
 222       context_type = LLVMStructTypeInContext(lc, elem_types,
 223                                              ARRAY_SIZE(elem_types), 0);
 224
 225       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, constants,
 226                              gallivm->target, context_type,
 227                              LP_JIT_CTX_CONSTANTS);
 228       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, num_constants,
 229                              gallivm->target, context_type,
 230                              LP_JIT_CTX_NUM_CONSTANTS);
 231       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, textures,
 232                              gallivm->target, context_type,
 233                              LP_JIT_CTX_TEXTURES);
 234       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, samplers,
 235                              gallivm->target, context_type,
 236                              LP_JIT_CTX_SAMPLERS);
 237       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, images,
 238                              gallivm->target, context_type,
 239                              LP_JIT_CTX_IMAGES);
 240       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, alpha_ref_value,
 241                              gallivm->target, context_type,
 242                              LP_JIT_CTX_ALPHA_REF);
 243       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, stencil_ref_front,
 244                              gallivm->target, context_type,
 245                              LP_JIT_CTX_STENCIL_REF_FRONT);
 246       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, stencil_ref_back,
 247                              gallivm->target, context_type,
 248                              LP_JIT_CTX_STENCIL_REF_BACK);
 249       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, u8_blend_color,
 250                              gallivm->target, context_type,
 251                              LP_JIT_CTX_U8_BLEND_COLOR);
 252       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, f_blend_color,
 253                              gallivm->target, context_type,
 254                              LP_JIT_CTX_F_BLEND_COLOR);
 255       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, viewports,
 256                              gallivm->target, context_type,
 257                              LP_JIT_CTX_VIEWPORTS);
 258       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, ssbos,
 259                              gallivm->target, context_type,
 260                              LP_JIT_CTX_SSBOS);
 261       LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, num_ssbos,
 262                              gallivm->target, context_type,
 263                              LP_JIT_CTX_NUM_SSBOS);
 264       LP_CHECK_STRUCT_SIZE(struct lp_jit_context,
 265                            gallivm->target, context_type);
 266
 267       lp->jit_context_ptr_type = LLVMPointerType(context_type, 0);
 268    }
 269
 270    /* struct lp_jit_thread_data */
 271    {
 272       LLVMTypeRef elem_types[LP_JIT_THREAD_DATA_COUNT];
 273       LLVMTypeRef thread_data_type;
 274
 275       elem_types[LP_JIT_THREAD_DATA_CACHE] =
 276             LLVMPointerType(lp_build_format_cache_type(gallivm), 0);
 277       elem_types[LP_JIT_THREAD_DATA_COUNTER] = LLVMInt64TypeInContext(lc);
 278       elem_types[LP_JIT_THREAD_DATA_INVOCATIONS] = LLVMInt64TypeInContext(lc);
 279       elem_types[LP_JIT_THREAD_DATA_RASTER_STATE_VIEWPORT_INDEX] =
 280             LLVMInt32TypeInContext(lc);
 281
 282       thread_data_type = LLVMStructTypeInContext(lc, elem_types,
 283                                                  ARRAY_SIZE(elem_types), 0);
 284
 285       lp->jit_thread_data_ptr_type = LLVMPointerType(thread_data_type, 0);
 286    }
 287
 288    if (gallivm_debug & GALLIVM_DEBUG_IR) {
 289       char *str = LLVMPrintModuleToString(gallivm->module);
 290       fprintf(stderr, "%s", str);
 291       LLVMDisposeMessage(str);
 292    }
 293 }
 294
 295
 296 void
 297 lp_jit_screen_cleanup(struct llvmpipe_screen *screen)
 298 {
 299    /* nothing */
 300 }
 301
 302
 303 boolean
 304 lp_jit_screen_init(struct llvmpipe_screen *screen)
 305 {
 306    return lp_build_init();
 307 }
 308
 309
 310 void
 311 lp_jit_init_types(struct lp_fragment_shader_variant *lp)
 312 {
 313    if (!lp->jit_context_ptr_type)
 314       lp_jit_create_types(lp);
 315 }
 316
 317 static void
 318 lp_jit_create_cs_types(struct lp_compute_shader_variant *lp)
 319 {
 320    struct gallivm_state *gallivm = lp->gallivm;
 321    LLVMContextRef lc = gallivm->context;
 322    LLVMTypeRef texture_type, sampler_type, image_type;
 323
 324    texture_type = create_jit_texture_type(gallivm);
 325    sampler_type = create_jit_sampler_type(gallivm);
 326    image_type = create_jit_image_type(gallivm);
 327
 328    /* struct lp_jit_cs_thread_data */
 329    {
 330       LLVMTypeRef elem_types[LP_JIT_CS_THREAD_DATA_COUNT];
 331       LLVMTypeRef thread_data_type;
 332
 333       elem_types[LP_JIT_CS_THREAD_DATA_CACHE] =
 334             LLVMPointerType(lp_build_format_cache_type(gallivm), 0);
 335
 336       elem_types[LP_JIT_CS_THREAD_DATA_SHARED] = LLVMPointerType(LLVMInt32TypeInContext(lc), 0);
 337       thread_data_type = LLVMStructTypeInContext(lc, elem_types,
 338                                                  ARRAY_SIZE(elem_types), 0);
 339
 340       lp->jit_cs_thread_data_ptr_type = LLVMPointerType(thread_data_type, 0);
 341    }
 342
 343    /* struct lp_jit_cs_context */
 344    {
 345       LLVMTypeRef elem_types[LP_JIT_CS_CTX_COUNT];
 346       LLVMTypeRef cs_context_type;
 347
 348       elem_types[LP_JIT_CS_CTX_CONSTANTS] =
 349          LLVMArrayType(LLVMPointerType(LLVMFloatTypeInContext(lc), 0), LP_MAX_TGSI_CONST_BUFFERS);
 350       elem_types[LP_JIT_CS_CTX_NUM_CONSTANTS] =
 351             LLVMArrayType(LLVMInt32TypeInContext(lc), LP_MAX_TGSI_CONST_BUFFERS);
 352       elem_types[LP_JIT_CS_CTX_TEXTURES] = LLVMArrayType(texture_type,
 353                                                       PIPE_MAX_SHADER_SAMPLER_VIEWS);
 354       elem_types[LP_JIT_CS_CTX_SAMPLERS] = LLVMArrayType(sampler_type,
 355                                                       PIPE_MAX_SAMPLERS);
 356       elem_types[LP_JIT_CS_CTX_IMAGES] = LLVMArrayType(image_type,
 357                                                        PIPE_MAX_SHADER_IMAGES);
 358       elem_types[LP_JIT_CS_CTX_SSBOS] =
 359          LLVMArrayType(LLVMPointerType(LLVMInt32TypeInContext(lc), 0), LP_MAX_TGSI_SHADER_BUFFERS);
 360       elem_types[LP_JIT_CS_CTX_NUM_SSBOS] =
 361             LLVMArrayType(LLVMInt32TypeInContext(lc), LP_MAX_TGSI_SHADER_BUFFERS);
 362
 363       elem_types[LP_JIT_CS_CTX_SHARED_SIZE] = LLVMInt32TypeInContext(lc);
 364
 365       elem_types[LP_JIT_CS_CTX_KERNEL_ARGS] = LLVMPointerType(LLVMInt8TypeInContext(lc), 0);
 366
 367       cs_context_type = LLVMStructTypeInContext(lc, elem_types,
 368                                              ARRAY_SIZE(elem_types), 0);
 369
 370       LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context, constants,
 371                              gallivm->target, cs_context_type,
 372                              LP_JIT_CS_CTX_CONSTANTS);
 373       LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context, num_constants,
 374                              gallivm->target, cs_context_type,
 375                              LP_JIT_CS_CTX_NUM_CONSTANTS);
 376       LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context, textures,
 377                              gallivm->target, cs_context_type,
 378                              LP_JIT_CS_CTX_TEXTURES);
 379       LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context, samplers,
 380                              gallivm->target, cs_context_type,
 381                              LP_JIT_CS_CTX_SAMPLERS);
 382       LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context, images,
 383                              gallivm->target, cs_context_type,
 384                              LP_JIT_CS_CTX_IMAGES);
 385       LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context, ssbos,
 386                              gallivm->target, cs_context_type,
 387                              LP_JIT_CS_CTX_SSBOS);
 388       LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context, num_ssbos,
 389                              gallivm->target, cs_context_type,
 390                              LP_JIT_CS_CTX_NUM_SSBOS);
 391       LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context, shared_size,
 392                              gallivm->target, cs_context_type,
 393                              LP_JIT_CS_CTX_SHARED_SIZE);
 394       LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context, kernel_args,
 395                              gallivm->target, cs_context_type,
 396                              LP_JIT_CS_CTX_KERNEL_ARGS);
 397       LP_CHECK_STRUCT_SIZE(struct lp_jit_cs_context,
 398                            gallivm->target, cs_context_type);
 399
 400       lp->jit_cs_context_ptr_type = LLVMPointerType(cs_context_type, 0);
 401    }
 402
 403    if (gallivm_debug & GALLIVM_DEBUG_IR) {
 404 #if (LLVM_VERSION_MAJOR > 3 || (LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR >= 4))
 405       char *str = LLVMPrintModuleToString(gallivm->module);
 406       fprintf(stderr, "%s", str);
 407       LLVMDisposeMessage(str);
 408 #else
 409       LLVMDumpModule(gallivm->module);
 410 #endif
 411    }
 412 }
 413
 414 void
 415 lp_jit_init_cs_types(struct lp_compute_shader_variant *lp)
 416 {
 417    if (!lp->jit_cs_context_ptr_type)
 418       lp_jit_create_cs_types(lp);
 419 }