1 /**************************************************************************
3 * Copyright 2009 VMware, Inc.
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
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.
26 **************************************************************************/
32 * @author Jose Fonseca <jfonseca@vmware.com>
35 #include <llvm/Config/llvm-config.h>
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"
45 create_jit_texture_type(struct gallivm_state
*gallivm
)
47 LLVMContextRef lc
= gallivm
->context
;
48 LLVMTypeRef texture_type
;
49 LLVMTypeRef elem_types
[LP_JIT_TEXTURE_NUM_FIELDS
];
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_NUM_SAMPLES
] =
56 elem_types
[LP_JIT_TEXTURE_SAMPLE_STRIDE
] =
57 elem_types
[LP_JIT_TEXTURE_FIRST_LEVEL
] =
58 elem_types
[LP_JIT_TEXTURE_LAST_LEVEL
] = LLVMInt32TypeInContext(lc
);
59 elem_types
[LP_JIT_TEXTURE_BASE
] = LLVMPointerType(LLVMInt8TypeInContext(lc
), 0);
60 elem_types
[LP_JIT_TEXTURE_ROW_STRIDE
] =
61 elem_types
[LP_JIT_TEXTURE_IMG_STRIDE
] =
62 elem_types
[LP_JIT_TEXTURE_MIP_OFFSETS
] =
63 LLVMArrayType(LLVMInt32TypeInContext(lc
), LP_MAX_TEXTURE_LEVELS
);
65 texture_type
= LLVMStructTypeInContext(lc
, elem_types
,
66 ARRAY_SIZE(elem_types
), 0);
68 LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture
, width
,
69 gallivm
->target
, texture_type
,
70 LP_JIT_TEXTURE_WIDTH
);
71 LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture
, height
,
72 gallivm
->target
, texture_type
,
73 LP_JIT_TEXTURE_HEIGHT
);
74 LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture
, depth
,
75 gallivm
->target
, texture_type
,
76 LP_JIT_TEXTURE_DEPTH
);
77 LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture
, base
,
78 gallivm
->target
, texture_type
,
80 LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture
, row_stride
,
81 gallivm
->target
, texture_type
,
82 LP_JIT_TEXTURE_ROW_STRIDE
);
83 LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture
, img_stride
,
84 gallivm
->target
, texture_type
,
85 LP_JIT_TEXTURE_IMG_STRIDE
);
86 LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture
, first_level
,
87 gallivm
->target
, texture_type
,
88 LP_JIT_TEXTURE_FIRST_LEVEL
);
89 LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture
, last_level
,
90 gallivm
->target
, texture_type
,
91 LP_JIT_TEXTURE_LAST_LEVEL
);
92 LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture
, mip_offsets
,
93 gallivm
->target
, texture_type
,
94 LP_JIT_TEXTURE_MIP_OFFSETS
);
95 LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture
, num_samples
,
96 gallivm
->target
, texture_type
,
97 LP_JIT_TEXTURE_NUM_SAMPLES
);
98 LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture
, sample_stride
,
99 gallivm
->target
, texture_type
,
100 LP_JIT_TEXTURE_SAMPLE_STRIDE
);
101 LP_CHECK_STRUCT_SIZE(struct lp_jit_texture
,
102 gallivm
->target
, texture_type
);
107 create_jit_sampler_type(struct gallivm_state
*gallivm
)
109 LLVMContextRef lc
= gallivm
->context
;
110 LLVMTypeRef sampler_type
;
111 LLVMTypeRef elem_types
[LP_JIT_SAMPLER_NUM_FIELDS
];
112 elem_types
[LP_JIT_SAMPLER_MIN_LOD
] =
113 elem_types
[LP_JIT_SAMPLER_MAX_LOD
] =
114 elem_types
[LP_JIT_SAMPLER_LOD_BIAS
] = LLVMFloatTypeInContext(lc
);
115 elem_types
[LP_JIT_SAMPLER_BORDER_COLOR
] =
116 LLVMArrayType(LLVMFloatTypeInContext(lc
), 4);
118 sampler_type
= LLVMStructTypeInContext(lc
, elem_types
,
119 ARRAY_SIZE(elem_types
), 0);
121 LP_CHECK_MEMBER_OFFSET(struct lp_jit_sampler
, min_lod
,
122 gallivm
->target
, sampler_type
,
123 LP_JIT_SAMPLER_MIN_LOD
);
124 LP_CHECK_MEMBER_OFFSET(struct lp_jit_sampler
, max_lod
,
125 gallivm
->target
, sampler_type
,
126 LP_JIT_SAMPLER_MAX_LOD
);
127 LP_CHECK_MEMBER_OFFSET(struct lp_jit_sampler
, lod_bias
,
128 gallivm
->target
, sampler_type
,
129 LP_JIT_SAMPLER_LOD_BIAS
);
130 LP_CHECK_MEMBER_OFFSET(struct lp_jit_sampler
, border_color
,
131 gallivm
->target
, sampler_type
,
132 LP_JIT_SAMPLER_BORDER_COLOR
);
133 LP_CHECK_STRUCT_SIZE(struct lp_jit_sampler
,
134 gallivm
->target
, sampler_type
);
139 create_jit_image_type(struct gallivm_state
*gallivm
)
141 LLVMContextRef lc
= gallivm
->context
;
142 LLVMTypeRef image_type
;
143 LLVMTypeRef elem_types
[LP_JIT_IMAGE_NUM_FIELDS
];
144 elem_types
[LP_JIT_IMAGE_WIDTH
] =
145 elem_types
[LP_JIT_IMAGE_HEIGHT
] =
146 elem_types
[LP_JIT_IMAGE_DEPTH
] = LLVMInt32TypeInContext(lc
);
147 elem_types
[LP_JIT_IMAGE_BASE
] = LLVMPointerType(LLVMInt8TypeInContext(lc
), 0);
148 elem_types
[LP_JIT_IMAGE_ROW_STRIDE
] =
149 elem_types
[LP_JIT_IMAGE_IMG_STRIDE
] =
150 elem_types
[LP_JIT_IMAGE_NUM_SAMPLES
] =
151 elem_types
[LP_JIT_IMAGE_SAMPLE_STRIDE
] = LLVMInt32TypeInContext(lc
);
153 image_type
= LLVMStructTypeInContext(lc
, elem_types
,
154 ARRAY_SIZE(elem_types
), 0);
155 LP_CHECK_MEMBER_OFFSET(struct lp_jit_image
, width
,
156 gallivm
->target
, image_type
,
158 LP_CHECK_MEMBER_OFFSET(struct lp_jit_image
, height
,
159 gallivm
->target
, image_type
,
160 LP_JIT_IMAGE_HEIGHT
);
161 LP_CHECK_MEMBER_OFFSET(struct lp_jit_image
, depth
,
162 gallivm
->target
, image_type
,
164 LP_CHECK_MEMBER_OFFSET(struct lp_jit_image
, base
,
165 gallivm
->target
, image_type
,
167 LP_CHECK_MEMBER_OFFSET(struct lp_jit_image
, row_stride
,
168 gallivm
->target
, image_type
,
169 LP_JIT_IMAGE_ROW_STRIDE
);
170 LP_CHECK_MEMBER_OFFSET(struct lp_jit_image
, img_stride
,
171 gallivm
->target
, image_type
,
172 LP_JIT_IMAGE_IMG_STRIDE
);
173 LP_CHECK_MEMBER_OFFSET(struct lp_jit_image
, num_samples
,
174 gallivm
->target
, image_type
,
175 LP_JIT_IMAGE_NUM_SAMPLES
);
176 LP_CHECK_MEMBER_OFFSET(struct lp_jit_image
, sample_stride
,
177 gallivm
->target
, image_type
,
178 LP_JIT_IMAGE_SAMPLE_STRIDE
);
183 lp_jit_create_types(struct lp_fragment_shader_variant
*lp
)
185 struct gallivm_state
*gallivm
= lp
->gallivm
;
186 LLVMContextRef lc
= gallivm
->context
;
187 LLVMTypeRef viewport_type
, texture_type
, sampler_type
, image_type
;
189 /* struct lp_jit_viewport */
191 LLVMTypeRef elem_types
[LP_JIT_VIEWPORT_NUM_FIELDS
];
193 elem_types
[LP_JIT_VIEWPORT_MIN_DEPTH
] =
194 elem_types
[LP_JIT_VIEWPORT_MAX_DEPTH
] = LLVMFloatTypeInContext(lc
);
196 viewport_type
= LLVMStructTypeInContext(lc
, elem_types
,
197 ARRAY_SIZE(elem_types
), 0);
199 LP_CHECK_MEMBER_OFFSET(struct lp_jit_viewport
, min_depth
,
200 gallivm
->target
, viewport_type
,
201 LP_JIT_VIEWPORT_MIN_DEPTH
);
202 LP_CHECK_MEMBER_OFFSET(struct lp_jit_viewport
, max_depth
,
203 gallivm
->target
, viewport_type
,
204 LP_JIT_VIEWPORT_MAX_DEPTH
);
205 LP_CHECK_STRUCT_SIZE(struct lp_jit_viewport
,
206 gallivm
->target
, viewport_type
);
209 texture_type
= create_jit_texture_type(gallivm
);
210 sampler_type
= create_jit_sampler_type(gallivm
);
211 image_type
= create_jit_image_type(gallivm
);
213 /* struct lp_jit_context */
215 LLVMTypeRef elem_types
[LP_JIT_CTX_COUNT
];
216 LLVMTypeRef context_type
;
218 elem_types
[LP_JIT_CTX_CONSTANTS
] =
219 LLVMArrayType(LLVMPointerType(LLVMFloatTypeInContext(lc
), 0), LP_MAX_TGSI_CONST_BUFFERS
);
220 elem_types
[LP_JIT_CTX_NUM_CONSTANTS
] =
221 LLVMArrayType(LLVMInt32TypeInContext(lc
), LP_MAX_TGSI_CONST_BUFFERS
);
222 elem_types
[LP_JIT_CTX_TEXTURES
] = LLVMArrayType(texture_type
,
223 PIPE_MAX_SHADER_SAMPLER_VIEWS
);
224 elem_types
[LP_JIT_CTX_SAMPLERS
] = LLVMArrayType(sampler_type
,
226 elem_types
[LP_JIT_CTX_IMAGES
] = LLVMArrayType(image_type
,
227 PIPE_MAX_SHADER_IMAGES
);
228 elem_types
[LP_JIT_CTX_ALPHA_REF
] = LLVMFloatTypeInContext(lc
);
229 elem_types
[LP_JIT_CTX_SAMPLE_MASK
] =
230 elem_types
[LP_JIT_CTX_STENCIL_REF_FRONT
] =
231 elem_types
[LP_JIT_CTX_STENCIL_REF_BACK
] = LLVMInt32TypeInContext(lc
);
232 elem_types
[LP_JIT_CTX_U8_BLEND_COLOR
] = LLVMPointerType(LLVMInt8TypeInContext(lc
), 0);
233 elem_types
[LP_JIT_CTX_F_BLEND_COLOR
] = LLVMPointerType(LLVMFloatTypeInContext(lc
), 0);
234 elem_types
[LP_JIT_CTX_VIEWPORTS
] = LLVMPointerType(viewport_type
, 0);
235 elem_types
[LP_JIT_CTX_SSBOS
] =
236 LLVMArrayType(LLVMPointerType(LLVMInt32TypeInContext(lc
), 0), LP_MAX_TGSI_SHADER_BUFFERS
);
237 elem_types
[LP_JIT_CTX_NUM_SSBOS
] =
238 LLVMArrayType(LLVMInt32TypeInContext(lc
), LP_MAX_TGSI_SHADER_BUFFERS
);
239 context_type
= LLVMStructTypeInContext(lc
, elem_types
,
240 ARRAY_SIZE(elem_types
), 0);
242 LP_CHECK_MEMBER_OFFSET(struct lp_jit_context
, constants
,
243 gallivm
->target
, context_type
,
244 LP_JIT_CTX_CONSTANTS
);
245 LP_CHECK_MEMBER_OFFSET(struct lp_jit_context
, num_constants
,
246 gallivm
->target
, context_type
,
247 LP_JIT_CTX_NUM_CONSTANTS
);
248 LP_CHECK_MEMBER_OFFSET(struct lp_jit_context
, textures
,
249 gallivm
->target
, context_type
,
250 LP_JIT_CTX_TEXTURES
);
251 LP_CHECK_MEMBER_OFFSET(struct lp_jit_context
, samplers
,
252 gallivm
->target
, context_type
,
253 LP_JIT_CTX_SAMPLERS
);
254 LP_CHECK_MEMBER_OFFSET(struct lp_jit_context
, images
,
255 gallivm
->target
, context_type
,
257 LP_CHECK_MEMBER_OFFSET(struct lp_jit_context
, alpha_ref_value
,
258 gallivm
->target
, context_type
,
259 LP_JIT_CTX_ALPHA_REF
);
260 LP_CHECK_MEMBER_OFFSET(struct lp_jit_context
, stencil_ref_front
,
261 gallivm
->target
, context_type
,
262 LP_JIT_CTX_STENCIL_REF_FRONT
);
263 LP_CHECK_MEMBER_OFFSET(struct lp_jit_context
, stencil_ref_back
,
264 gallivm
->target
, context_type
,
265 LP_JIT_CTX_STENCIL_REF_BACK
);
266 LP_CHECK_MEMBER_OFFSET(struct lp_jit_context
, u8_blend_color
,
267 gallivm
->target
, context_type
,
268 LP_JIT_CTX_U8_BLEND_COLOR
);
269 LP_CHECK_MEMBER_OFFSET(struct lp_jit_context
, f_blend_color
,
270 gallivm
->target
, context_type
,
271 LP_JIT_CTX_F_BLEND_COLOR
);
272 LP_CHECK_MEMBER_OFFSET(struct lp_jit_context
, viewports
,
273 gallivm
->target
, context_type
,
274 LP_JIT_CTX_VIEWPORTS
);
275 LP_CHECK_MEMBER_OFFSET(struct lp_jit_context
, ssbos
,
276 gallivm
->target
, context_type
,
278 LP_CHECK_MEMBER_OFFSET(struct lp_jit_context
, num_ssbos
,
279 gallivm
->target
, context_type
,
280 LP_JIT_CTX_NUM_SSBOS
);
281 LP_CHECK_MEMBER_OFFSET(struct lp_jit_context
, sample_mask
,
282 gallivm
->target
, context_type
,
283 LP_JIT_CTX_SAMPLE_MASK
);
284 LP_CHECK_STRUCT_SIZE(struct lp_jit_context
,
285 gallivm
->target
, context_type
);
287 lp
->jit_context_ptr_type
= LLVMPointerType(context_type
, 0);
290 /* struct lp_jit_thread_data */
292 LLVMTypeRef elem_types
[LP_JIT_THREAD_DATA_COUNT
];
293 LLVMTypeRef thread_data_type
;
295 elem_types
[LP_JIT_THREAD_DATA_CACHE
] =
296 LLVMPointerType(lp_build_format_cache_type(gallivm
), 0);
297 elem_types
[LP_JIT_THREAD_DATA_COUNTER
] = LLVMInt64TypeInContext(lc
);
298 elem_types
[LP_JIT_THREAD_DATA_INVOCATIONS
] = LLVMInt64TypeInContext(lc
);
299 elem_types
[LP_JIT_THREAD_DATA_RASTER_STATE_VIEWPORT_INDEX
] =
300 LLVMInt32TypeInContext(lc
);
302 thread_data_type
= LLVMStructTypeInContext(lc
, elem_types
,
303 ARRAY_SIZE(elem_types
), 0);
305 lp
->jit_thread_data_ptr_type
= LLVMPointerType(thread_data_type
, 0);
308 if (gallivm_debug
& GALLIVM_DEBUG_IR
) {
309 char *str
= LLVMPrintModuleToString(gallivm
->module
);
310 fprintf(stderr
, "%s", str
);
311 LLVMDisposeMessage(str
);
317 lp_jit_screen_cleanup(struct llvmpipe_screen
*screen
)
324 lp_jit_screen_init(struct llvmpipe_screen
*screen
)
326 return lp_build_init();
331 lp_jit_init_types(struct lp_fragment_shader_variant
*lp
)
333 if (!lp
->jit_context_ptr_type
)
334 lp_jit_create_types(lp
);
338 lp_jit_create_cs_types(struct lp_compute_shader_variant
*lp
)
340 struct gallivm_state
*gallivm
= lp
->gallivm
;
341 LLVMContextRef lc
= gallivm
->context
;
342 LLVMTypeRef texture_type
, sampler_type
, image_type
;
344 texture_type
= create_jit_texture_type(gallivm
);
345 sampler_type
= create_jit_sampler_type(gallivm
);
346 image_type
= create_jit_image_type(gallivm
);
348 /* struct lp_jit_cs_thread_data */
350 LLVMTypeRef elem_types
[LP_JIT_CS_THREAD_DATA_COUNT
];
351 LLVMTypeRef thread_data_type
;
353 elem_types
[LP_JIT_CS_THREAD_DATA_CACHE
] =
354 LLVMPointerType(lp_build_format_cache_type(gallivm
), 0);
356 elem_types
[LP_JIT_CS_THREAD_DATA_SHARED
] = LLVMPointerType(LLVMInt32TypeInContext(lc
), 0);
357 thread_data_type
= LLVMStructTypeInContext(lc
, elem_types
,
358 ARRAY_SIZE(elem_types
), 0);
360 lp
->jit_cs_thread_data_ptr_type
= LLVMPointerType(thread_data_type
, 0);
363 /* struct lp_jit_cs_context */
365 LLVMTypeRef elem_types
[LP_JIT_CS_CTX_COUNT
];
366 LLVMTypeRef cs_context_type
;
368 elem_types
[LP_JIT_CS_CTX_CONSTANTS
] =
369 LLVMArrayType(LLVMPointerType(LLVMFloatTypeInContext(lc
), 0), LP_MAX_TGSI_CONST_BUFFERS
);
370 elem_types
[LP_JIT_CS_CTX_NUM_CONSTANTS
] =
371 LLVMArrayType(LLVMInt32TypeInContext(lc
), LP_MAX_TGSI_CONST_BUFFERS
);
372 elem_types
[LP_JIT_CS_CTX_TEXTURES
] = LLVMArrayType(texture_type
,
373 PIPE_MAX_SHADER_SAMPLER_VIEWS
);
374 elem_types
[LP_JIT_CS_CTX_SAMPLERS
] = LLVMArrayType(sampler_type
,
376 elem_types
[LP_JIT_CS_CTX_IMAGES
] = LLVMArrayType(image_type
,
377 PIPE_MAX_SHADER_IMAGES
);
378 elem_types
[LP_JIT_CS_CTX_SSBOS
] =
379 LLVMArrayType(LLVMPointerType(LLVMInt32TypeInContext(lc
), 0), LP_MAX_TGSI_SHADER_BUFFERS
);
380 elem_types
[LP_JIT_CS_CTX_NUM_SSBOS
] =
381 LLVMArrayType(LLVMInt32TypeInContext(lc
), LP_MAX_TGSI_SHADER_BUFFERS
);
383 elem_types
[LP_JIT_CS_CTX_SHARED_SIZE
] = LLVMInt32TypeInContext(lc
);
385 elem_types
[LP_JIT_CS_CTX_KERNEL_ARGS
] = LLVMPointerType(LLVMInt8TypeInContext(lc
), 0);
387 cs_context_type
= LLVMStructTypeInContext(lc
, elem_types
,
388 ARRAY_SIZE(elem_types
), 0);
390 LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context
, constants
,
391 gallivm
->target
, cs_context_type
,
392 LP_JIT_CS_CTX_CONSTANTS
);
393 LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context
, num_constants
,
394 gallivm
->target
, cs_context_type
,
395 LP_JIT_CS_CTX_NUM_CONSTANTS
);
396 LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context
, textures
,
397 gallivm
->target
, cs_context_type
,
398 LP_JIT_CS_CTX_TEXTURES
);
399 LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context
, samplers
,
400 gallivm
->target
, cs_context_type
,
401 LP_JIT_CS_CTX_SAMPLERS
);
402 LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context
, images
,
403 gallivm
->target
, cs_context_type
,
404 LP_JIT_CS_CTX_IMAGES
);
405 LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context
, ssbos
,
406 gallivm
->target
, cs_context_type
,
407 LP_JIT_CS_CTX_SSBOS
);
408 LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context
, num_ssbos
,
409 gallivm
->target
, cs_context_type
,
410 LP_JIT_CS_CTX_NUM_SSBOS
);
411 LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context
, shared_size
,
412 gallivm
->target
, cs_context_type
,
413 LP_JIT_CS_CTX_SHARED_SIZE
);
414 LP_CHECK_MEMBER_OFFSET(struct lp_jit_cs_context
, kernel_args
,
415 gallivm
->target
, cs_context_type
,
416 LP_JIT_CS_CTX_KERNEL_ARGS
);
417 LP_CHECK_STRUCT_SIZE(struct lp_jit_cs_context
,
418 gallivm
->target
, cs_context_type
);
420 lp
->jit_cs_context_ptr_type
= LLVMPointerType(cs_context_type
, 0);
423 if (gallivm_debug
& GALLIVM_DEBUG_IR
) {
424 char *str
= LLVMPrintModuleToString(gallivm
->module
);
425 fprintf(stderr
, "%s", str
);
426 LLVMDisposeMessage(str
);
431 lp_jit_init_cs_types(struct lp_compute_shader_variant
*lp
)
433 if (!lp
->jit_cs_context_ptr_type
)
434 lp_jit_create_cs_types(lp
);