1 /**************************************************************************
2 *
3 * Copyright 2008 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 "util/u_memory.h"
30 #include "util/u_math.h"
31 #include "util/u_cpu_detect.h"
32 #include "util/format/u_format.h"
33 #include "util/u_screen.h"
34 #include "util/u_string.h"
35 #include "util/format/u_format_s3tc.h"
36 #include "pipe/p_defines.h"
37 #include "pipe/p_screen.h"
38 #include "draw/draw_context.h"
39 #include "gallivm/lp_bld_type.h"
40 #include "gallivm/lp_bld_nir.h"
41 #include "util/disk_cache.h"
42 #include "util/hex.h"
43 #include "util/os_misc.h"
44 #include "util/os_time.h"
45 #include "util/u_helpers.h"
46 #include "util/anon_file.h"
47 #include "lp_texture.h"
48 #include "lp_fence.h"
49 #include "lp_jit.h"
50 #include "lp_screen.h"
51 #include "lp_context.h"
52 #include "lp_debug.h"
53 #include "lp_public.h"
54 #include "lp_limits.h"
55 #include "lp_rast.h"
56 #include "lp_cs_tpool.h"
57 #include "lp_flush.h"
58
59 #include "frontend/sw_winsys.h"
60
61 #include "nir.h"
62
63 #ifdef HAVE_LIBDRM
64 #include <xf86drm.h>
65 #include <fcntl.h>
66 #endif
67
68 int LP_DEBUG = 0;
69
70 static const struct debug_named_value lp_debug_flags[] = {
71 { "pipe", DEBUG_PIPE, NULL },
72 { "tgsi", DEBUG_TGSI, NULL },
73 { "tex", DEBUG_TEX, NULL },
74 { "setup", DEBUG_SETUP, NULL },
75 { "rast", DEBUG_RAST, NULL },
76 { "query", DEBUG_QUERY, NULL },
77 { "screen", DEBUG_SCREEN, NULL },
78 { "counters", DEBUG_COUNTERS, NULL },
79 { "scene", DEBUG_SCENE, NULL },
80 { "fence", DEBUG_FENCE, NULL },
81 { "no_fastpath", DEBUG_NO_FASTPATH, NULL },
82 { "linear", DEBUG_LINEAR, NULL },
83 { "linear2", DEBUG_LINEAR2, NULL },
84 { "mem", DEBUG_MEM, NULL },
85 { "fs", DEBUG_FS, NULL },
86 { "cs", DEBUG_CS, NULL },
87 { "accurate_a0", DEBUG_ACCURATE_A0 },
88 { "mesh", DEBUG_MESH },
89 DEBUG_NAMED_VALUE_END
90 };
91
92 int LP_PERF = 0;
93 static const struct debug_named_value lp_perf_flags[] = {
94 { "texmem", PERF_TEX_MEM, NULL },
95 { "no_mipmap", PERF_NO_MIPMAPS, NULL },
96 { "no_linear", PERF_NO_LINEAR, NULL },
97 { "no_mip_linear", PERF_NO_MIP_LINEAR, NULL },
98 { "no_tex", PERF_NO_TEX, NULL },
99 { "no_blend", PERF_NO_BLEND, NULL },
100 { "no_depth", PERF_NO_DEPTH, NULL },
101 { "no_alphatest", PERF_NO_ALPHATEST, NULL },
102 { "no_rast_linear", PERF_NO_RAST_LINEAR, NULL },
103 { "no_shade", PERF_NO_SHADE, NULL },
104 DEBUG_NAMED_VALUE_END
105 };
106
107
108 static const char *
llvmpipe_get_vendor(struct pipe_screen * screen)109 llvmpipe_get_vendor(struct pipe_screen *screen)
110 {
111 return "Mesa";
112 }
113
114
115 static const char *
llvmpipe_get_name(struct pipe_screen * screen)116 llvmpipe_get_name(struct pipe_screen *screen)
117 {
118 struct llvmpipe_screen *lscreen = llvmpipe_screen(screen);
119 return lscreen->renderer_string;
120 }
121
122
123 static int
llvmpipe_get_shader_param(struct pipe_screen * screen,enum pipe_shader_type shader,enum pipe_shader_cap param)124 llvmpipe_get_shader_param(struct pipe_screen *screen,
125 enum pipe_shader_type shader,
126 enum pipe_shader_cap param)
127 {
128 struct llvmpipe_screen *lscreen = llvmpipe_screen(screen);
129 switch (shader) {
130 case PIPE_SHADER_COMPUTE:
131 if ((lscreen->allow_cl) && param == PIPE_SHADER_CAP_SUPPORTED_IRS)
132 return ((1 << PIPE_SHADER_IR_TGSI) |
133 (1 << PIPE_SHADER_IR_NIR));
134 FALLTHROUGH;
135 case PIPE_SHADER_MESH:
136 case PIPE_SHADER_TASK:
137 case PIPE_SHADER_FRAGMENT:
138 return gallivm_get_shader_param(param);
139 case PIPE_SHADER_TESS_CTRL:
140 case PIPE_SHADER_TESS_EVAL:
141 /* Tessellation shader needs llvm coroutines support */
142 if (!GALLIVM_COROUTINES)
143 return 0;
144 FALLTHROUGH;
145 case PIPE_SHADER_VERTEX:
146 case PIPE_SHADER_GEOMETRY:
147 switch (param) {
148 case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
149 /* At this time, the draw module and llvmpipe driver only
150 * support vertex shader texture lookups when LLVM is enabled in
151 * the draw module.
152 */
153 if (debug_get_bool_option("DRAW_USE_LLVM", true))
154 return PIPE_MAX_SAMPLERS;
155 else
156 return 0;
157 case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS:
158 if (debug_get_bool_option("DRAW_USE_LLVM", true))
159 return PIPE_MAX_SHADER_SAMPLER_VIEWS;
160 else
161 return 0;
162 case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
163 if (debug_get_bool_option("DRAW_USE_LLVM", false))
164 return LP_MAX_TGSI_CONST_BUFFERS;
165 else
166 return draw_get_shader_param(shader, param);
167 default:
168 return draw_get_shader_param(shader, param);
169 }
170 default:
171 return 0;
172 }
173 }
174
175
176 static int
llvmpipe_get_compute_param(struct pipe_screen * _screen,enum pipe_shader_ir ir_type,enum pipe_compute_cap param,void * ret)177 llvmpipe_get_compute_param(struct pipe_screen *_screen,
178 enum pipe_shader_ir ir_type,
179 enum pipe_compute_cap param,
180 void *ret)
181 {
182 switch (param) {
183 case PIPE_COMPUTE_CAP_IR_TARGET:
184 return 0;
185 case PIPE_COMPUTE_CAP_MAX_GRID_SIZE:
186 if (ret) {
187 uint64_t *grid_size = ret;
188 grid_size[0] = 65535;
189 grid_size[1] = 65535;
190 grid_size[2] = 65535;
191 }
192 return 3 * sizeof(uint64_t) ;
193 case PIPE_COMPUTE_CAP_MAX_BLOCK_SIZE:
194 if (ret) {
195 uint64_t *block_size = ret;
196 block_size[0] = 1024;
197 block_size[1] = 1024;
198 block_size[2] = 1024;
199 }
200 return 3 * sizeof(uint64_t);
201 case PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK:
202 if (ret) {
203 uint64_t *max_threads_per_block = ret;
204 *max_threads_per_block = 1024;
205 }
206 return sizeof(uint64_t);
207 case PIPE_COMPUTE_CAP_MAX_LOCAL_SIZE:
208 if (ret) {
209 uint64_t *max_local_size = ret;
210 *max_local_size = 32768;
211 }
212 return sizeof(uint64_t);
213 case PIPE_COMPUTE_CAP_GRID_DIMENSION:
214 if (ret) {
215 uint64_t *grid_dim = ret;
216 *grid_dim = 3;
217 }
218 return sizeof(uint64_t);
219 case PIPE_COMPUTE_CAP_MAX_GLOBAL_SIZE:
220 if (ret) {
221 uint64_t *max_global_size = ret;
222 *max_global_size = (1ULL << 31);
223 }
224 return sizeof(uint64_t);
225 case PIPE_COMPUTE_CAP_MAX_MEM_ALLOC_SIZE:
226 if (ret) {
227 uint64_t *max_mem_alloc_size = ret;
228 *max_mem_alloc_size = (1ULL << 31);
229 }
230 return sizeof(uint64_t);
231 case PIPE_COMPUTE_CAP_MAX_PRIVATE_SIZE:
232 if (ret) {
233 uint64_t *max_private = ret;
234 *max_private = (1UL << 31);
235 }
236 return sizeof(uint64_t);
237 case PIPE_COMPUTE_CAP_MAX_INPUT_SIZE:
238 if (ret) {
239 uint64_t *max_input = ret;
240 *max_input = 1576;
241 }
242 return sizeof(uint64_t);
243 case PIPE_COMPUTE_CAP_IMAGES_SUPPORTED:
244 if (ret) {
245 uint32_t *images = ret;
246 *images = LP_MAX_TGSI_SHADER_IMAGES;
247 }
248 return sizeof(uint32_t);
249 case PIPE_COMPUTE_CAP_MAX_VARIABLE_THREADS_PER_BLOCK:
250 return 0;
251 case PIPE_COMPUTE_CAP_SUBGROUP_SIZES:
252 if (ret) {
253 uint32_t *subgroup_size = ret;
254 *subgroup_size = lp_native_vector_width / 32;
255 }
256 return sizeof(uint32_t);
257 case PIPE_COMPUTE_CAP_MAX_SUBGROUPS:
258 if (ret) {
259 uint32_t *subgroup_size = ret;
260 *subgroup_size = 1024 / (lp_native_vector_width / 32);
261 }
262 return sizeof(uint32_t);
263 case PIPE_COMPUTE_CAP_MAX_COMPUTE_UNITS:
264 if (ret) {
265 uint32_t *max_compute_units = ret;
266 *max_compute_units = 8;
267 }
268 return sizeof(uint32_t);
269 case PIPE_COMPUTE_CAP_MAX_CLOCK_FREQUENCY:
270 if (ret) {
271 uint32_t *max_clock_freq = ret;
272 *max_clock_freq = 300;
273 }
274 return sizeof(uint32_t);
275 case PIPE_COMPUTE_CAP_ADDRESS_BITS:
276 if (ret) {
277 uint32_t *address_bits = ret;
278 *address_bits = sizeof(void*) * 8;
279 }
280 return sizeof(uint32_t);
281 }
282 return 0;
283 }
284
285
286 static void
llvmpipe_init_screen_caps(struct pipe_screen * screen)287 llvmpipe_init_screen_caps(struct pipe_screen *screen)
288 {
289 struct pipe_caps *caps = (struct pipe_caps *)&screen->caps;
290
291 u_init_pipe_screen_caps(screen, 0);
292
293 #ifdef HAVE_LIBDRM
294 struct llvmpipe_screen *lscreen = llvmpipe_screen(screen);
295 #endif
296
297 #ifdef HAVE_LIBDRM
298 if (lscreen->winsys->get_fd)
299 caps->dmabuf = DRM_PRIME_CAP_IMPORT | DRM_PRIME_CAP_EXPORT;
300 #ifdef HAVE_LINUX_UDMABUF_H
301 else if (lscreen->udmabuf_fd != -1)
302 caps->dmabuf = DRM_PRIME_CAP_IMPORT | DRM_PRIME_CAP_EXPORT;
303 else
304 caps->dmabuf = DRM_PRIME_CAP_IMPORT;
305 #endif
306 #else
307 caps->dmabuf = 0;
308 #endif
309
310 #if defined(HAVE_LIBDRM) && defined(HAVE_LINUX_UDMABUF_H)
311 caps->native_fence_fd = lscreen->dummy_sync_fd != -1;
312 #endif
313 caps->npot_textures = true;
314 caps->mixed_framebuffer_sizes = true;
315 caps->mixed_color_depth_bits = true;
316 caps->anisotropic_filter = true;
317 caps->fragment_shader_texture_lod = true;
318 caps->fragment_shader_derivatives = true;
319 caps->multiview = 2;
320 caps->max_dual_source_render_targets = 1;
321 caps->max_stream_output_buffers = PIPE_MAX_SO_BUFFERS;
322 caps->max_render_targets = PIPE_MAX_COLOR_BUFS;
323 caps->occlusion_query = true;
324 caps->query_timestamp = true;
325 caps->timer_resolution = true;
326 caps->query_time_elapsed = true;
327 caps->query_pipeline_statistics = true;
328 caps->texture_mirror_clamp = true;
329 caps->texture_mirror_clamp_to_edge = true;
330 caps->texture_swizzle = true;
331 caps->texture_shadow_lod = true;
332 caps->max_texture_2d_size = 1 << (LP_MAX_TEXTURE_2D_LEVELS - 1);
333 caps->max_texture_3d_levels = LP_MAX_TEXTURE_3D_LEVELS;
334 caps->max_texture_cube_levels = LP_MAX_TEXTURE_CUBE_LEVELS;
335 caps->max_texture_array_layers = LP_MAX_TEXTURE_ARRAY_LAYERS;
336 caps->blend_equation_separate = true;
337 caps->indep_blend_enable = true;
338 caps->indep_blend_func = true;
339 caps->fs_coord_origin_upper_left = true;
340 caps->fs_coord_pixel_center_integer = true;
341 caps->fs_coord_pixel_center_half_integer = true;
342 caps->primitive_restart = true;
343 caps->primitive_restart_fixed_index = true;
344 caps->depth_clip_disable = true;
345 caps->depth_clamp_enable = true;
346 caps->shader_stencil_export = true;
347 caps->vs_instanceid = true;
348 caps->vertex_element_instance_divisor = true;
349 caps->start_instance = true;
350 caps->seamless_cube_map = true;
351 caps->seamless_cube_map_per_texture = true;
352 /* this is a lie could support arbitrary large offsets */
353 caps->min_texture_gather_offset =
354 caps->min_texel_offset = -32;
355 caps->max_texture_gather_offset =
356 caps->max_texel_offset = 31;
357 caps->conditional_render = true;
358 caps->texture_barrier = true;
359 caps->max_stream_output_separate_components =
360 caps->max_stream_output_interleaved_components = 16*4;
361 caps->max_geometry_output_vertices =
362 caps->max_geometry_total_output_components = 1024;
363 caps->max_vertex_streams = 4;
364 caps->max_vertex_attrib_stride = 2048;
365 caps->stream_output_pause_resume = true;
366 caps->stream_output_interleave_buffers = true;
367 caps->vertex_color_unclamped = true;
368 caps->vertex_color_clamped = true;
369 caps->glsl_feature_level_compatibility =
370 caps->glsl_feature_level = 450;
371 caps->compute = GALLIVM_COROUTINES;
372 caps->user_vertex_buffers = true;
373 caps->tgsi_texcoord = true;
374 caps->draw_indirect = true;
375
376 caps->cube_map_array = true;
377 caps->constant_buffer_offset_alignment = 16;
378 caps->min_map_buffer_alignment = 64;
379 caps->texture_buffer_objects = true;
380 caps->linear_image_pitch_alignment = 1;
381 caps->linear_image_base_address_alignment = 1;
382 /* Adressing that many 64bpp texels fits in an i32 so this is a reasonable value */
383 caps->max_texel_buffer_elements = LP_MAX_TEXEL_BUFFER_ELEMENTS;
384 caps->texture_buffer_offset_alignment = 16;
385 caps->texture_transfer_modes = 0;
386 caps->max_viewports = PIPE_MAX_VIEWPORTS;
387 caps->endianness = PIPE_ENDIAN_NATIVE;
388 caps->tes_layer_viewport = true;
389 caps->vs_layer_viewport = true;
390 caps->max_texture_gather_components = 4;
391 caps->vs_window_space_position = true;
392 caps->fs_fine_derivative = true;
393 caps->tgsi_tex_txf_lz = true;
394 caps->sampler_view_target = true;
395 caps->fake_sw_msaa = false;
396 caps->texture_query_lod = true;
397 caps->conditional_render_inverted = true;
398 caps->shader_array_components = true;
399 caps->doubles = true;
400 caps->int64 = true;
401 caps->query_so_overflow = true;
402 caps->tgsi_div = true;
403 caps->vendor_id = 0xFFFFFFFF;
404 caps->device_id = 0xFFFFFFFF;
405
406 /* XXX: Do we want to return the full amount fo system memory ? */
407 uint64_t system_memory;
408 if (os_get_total_physical_memory(&system_memory)) {
409 if (sizeof(void *) == 4)
410 /* Cap to 2 GB on 32 bits system. We do this because llvmpipe does
411 * eat application memory, which is quite limited on 32 bits. App
412 * shouldn't expect too much available memory. */
413 system_memory = MIN2(system_memory, 2048 << 20);
414
415 caps->video_memory = system_memory >> 20;
416 } else {
417 caps->video_memory = 0;
418 }
419
420 caps->uma = true;
421 caps->query_memory_info = true;
422 caps->clip_halfz = true;
423 caps->polygon_offset_clamp = true;
424 caps->texture_float_linear = true;
425 caps->texture_half_float_linear = true;
426 caps->cull_distance = true;
427 caps->copy_between_compressed_and_plain_formats = true;
428 caps->max_varyings = 32;
429 caps->shader_buffer_offset_alignment = 16;
430 caps->query_buffer_object = true;
431 caps->draw_parameters = true;
432 caps->fbfetch = 8;
433 caps->fbfetch_coherent = true;
434 caps->fbfetch_zs = true;
435 caps->multi_draw_indirect = true;
436 caps->multi_draw_indirect_params = true;
437 caps->device_reset_status_query = true;
438 caps->robust_buffer_access_behavior = true;
439 caps->max_shader_patch_varyings = 32;
440 caps->rasterizer_subpixel_bits = 8;
441 caps->pci_group =
442 caps->pci_bus =
443 caps->pci_device =
444 caps->pci_function = 0;
445 caps->allow_mapped_buffers_during_execution = false;
446
447 /* Can't expose shareable shaders because the draw shaders reference the
448 * draw module's state, which is per-context.
449 */
450 caps->shareable_shaders = false;
451 caps->max_gs_invocations = 32;
452 caps->max_shader_buffer_size = LP_MAX_TGSI_SHADER_BUFFER_SIZE;
453 caps->framebuffer_no_attachment = true;
454 caps->tgsi_tg4_component_in_swizzle = true;
455 caps->fs_face_is_integer_sysval = true;
456 caps->resource_from_user_memory = true;
457 caps->image_store_formatted = true;
458 caps->image_load_formatted = true;
459 #ifdef PIPE_MEMORY_FD
460 caps->memobj = true;
461 #endif
462 caps->sampler_reduction_minmax = true;
463 caps->texture_query_samples = true;
464 caps->shader_group_vote = true;
465 caps->shader_ballot = true;
466 caps->image_atomic_float_add = true;
467 caps->load_constbuf = true;
468 caps->texture_multisample = true;
469 caps->sample_shading = true;
470 caps->gl_spirv = true;
471 caps->post_depth_coverage = true;
472 caps->shader_clock = true;
473 caps->packed_uniforms = true;
474 caps->system_svm = true;
475 caps->atomic_float_minmax = LLVM_VERSION_MAJOR >= 15;
476 caps->nir_images_as_deref = false;
477 caps->alpha_to_coverage_dither_control = true;
478
479 caps->min_line_width =
480 caps->min_line_width_aa =
481 caps->min_point_size =
482 caps->min_point_size_aa = 1.0;
483 caps->point_size_granularity =
484 caps->line_width_granularity = 0.1;
485 caps->max_line_width =
486 caps->max_line_width_aa = 255.0; /* arbitrary */
487 caps->max_point_size =
488 caps->max_point_size_aa = LP_MAX_POINT_WIDTH; /* arbitrary */
489 caps->max_texture_anisotropy = 16.0; /* not actually signficant at this time */
490 caps->max_texture_lod_bias = 16.0; /* arbitrary */
491 }
492
493
494 static void
llvmpipe_get_driver_uuid(struct pipe_screen * pscreen,char * uuid)495 llvmpipe_get_driver_uuid(struct pipe_screen *pscreen, char *uuid)
496 {
497 memset(uuid, 0, PIPE_UUID_SIZE);
498 snprintf(uuid, PIPE_UUID_SIZE, "llvmpipeUUID");
499 }
500
501
502 static void
llvmpipe_get_device_uuid(struct pipe_screen * pscreen,char * uuid)503 llvmpipe_get_device_uuid(struct pipe_screen *pscreen, char *uuid)
504 {
505 memset(uuid, 0, PIPE_UUID_SIZE);
506 #if defined(__clang__)
507 #pragma GCC diagnostic push
508 #pragma GCC diagnostic ignored "-Wunknown-warning-option"
509 #pragma GCC diagnostic ignored "-Wformat-truncation"
510 #endif /* __clang__ */
511 snprintf(uuid, PIPE_UUID_SIZE, "mesa" PACKAGE_VERSION);
512 #if defined(__clang__)
513 #pragma GCC diagnostic pop
514 #endif /* __clang__ */
515 }
516
517
518 static const struct nir_shader_compiler_options gallivm_nir_options = {
519 .lower_scmp = true,
520 .lower_flrp32 = true,
521 .lower_flrp64 = true,
522 .lower_fsat = true,
523 .lower_bitfield_insert = true,
524 .lower_bitfield_extract = true,
525 .lower_fdot = true,
526 .lower_fdph = true,
527 .lower_ffma16 = true,
528 .lower_ffma32 = true,
529 .lower_ffma64 = true,
530 .lower_flrp16 = true,
531 .lower_fmod = true,
532 .lower_hadd = true,
533 .lower_uadd_sat = true,
534 .lower_usub_sat = true,
535 .lower_iadd_sat = true,
536 .lower_ldexp = true,
537 .lower_pack_snorm_2x16 = true,
538 .lower_pack_snorm_4x8 = true,
539 .lower_pack_unorm_2x16 = true,
540 .lower_pack_unorm_4x8 = true,
541 .lower_pack_half_2x16 = true,
542 .lower_pack_split = true,
543 .lower_unpack_snorm_2x16 = true,
544 .lower_unpack_snorm_4x8 = true,
545 .lower_unpack_unorm_2x16 = true,
546 .lower_unpack_unorm_4x8 = true,
547 .lower_unpack_half_2x16 = true,
548 .lower_extract_byte = true,
549 .lower_extract_word = true,
550 .lower_insert_byte = true,
551 .lower_insert_word = true,
552 .lower_uadd_carry = true,
553 .lower_usub_borrow = true,
554 .lower_mul_2x32_64 = true,
555 .lower_ifind_msb = true,
556 .lower_int64_options = nir_lower_imul_2x32_64,
557 .lower_doubles_options = nir_lower_dround_even,
558 .max_unroll_iterations = 32,
559 .lower_to_scalar = true,
560 .lower_uniforms_to_ubo = true,
561 .lower_vector_cmp = true,
562 .lower_device_index_to_zero = true,
563 .support_16bit_alu = true,
564 .lower_fisnormal = true,
565 .lower_fquantize2f16 = true,
566 .lower_fminmax_signed_zero = true,
567 .driver_functions = true,
568 .scalarize_ddx = true,
569 .support_indirect_inputs = (uint8_t)BITFIELD_MASK(PIPE_SHADER_TYPES),
570 .support_indirect_outputs = (uint8_t)BITFIELD_MASK(PIPE_SHADER_TYPES),
571 };
572
573
574 static char *
llvmpipe_finalize_nir(struct pipe_screen * screen,struct nir_shader * nir)575 llvmpipe_finalize_nir(struct pipe_screen *screen,
576 struct nir_shader *nir)
577 {
578 lp_build_opt_nir(nir);
579 return NULL;
580 }
581
582
583 static inline const void *
llvmpipe_get_compiler_options(struct pipe_screen * screen,enum pipe_shader_ir ir,enum pipe_shader_type shader)584 llvmpipe_get_compiler_options(struct pipe_screen *screen,
585 enum pipe_shader_ir ir,
586 enum pipe_shader_type shader)
587 {
588 assert(ir == PIPE_SHADER_IR_NIR);
589 return &gallivm_nir_options;
590 }
591
592
593 bool
lp_storage_render_image_format_supported(enum pipe_format format)594 lp_storage_render_image_format_supported(enum pipe_format format)
595 {
596 const struct util_format_description *format_desc = util_format_description(format);
597
598 if (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) {
599 /* this is a lie actually other formats COULD exist where we would fail */
600 if (format_desc->nr_channels < 3)
601 return false;
602 } else if (format_desc->colorspace != UTIL_FORMAT_COLORSPACE_RGB) {
603 return false;
604 }
605
606 if (format_desc->layout != UTIL_FORMAT_LAYOUT_PLAIN &&
607 format != PIPE_FORMAT_R11G11B10_FLOAT)
608 return false;
609
610 assert(format_desc->block.width == 1);
611 assert(format_desc->block.height == 1);
612
613 if (format_desc->is_mixed)
614 return false;
615
616 if (!format_desc->is_array && !format_desc->is_bitmask &&
617 format != PIPE_FORMAT_R11G11B10_FLOAT)
618 return false;
619
620 return true;
621 }
622
623
624 bool
lp_storage_image_format_supported(enum pipe_format format)625 lp_storage_image_format_supported(enum pipe_format format)
626 {
627 switch (format) {
628 case PIPE_FORMAT_R32G32B32A32_FLOAT:
629 case PIPE_FORMAT_R16G16B16A16_FLOAT:
630 case PIPE_FORMAT_R32G32_FLOAT:
631 case PIPE_FORMAT_R16G16_FLOAT:
632 case PIPE_FORMAT_R11G11B10_FLOAT:
633 case PIPE_FORMAT_R32_FLOAT:
634 case PIPE_FORMAT_R16_FLOAT:
635 case PIPE_FORMAT_R32G32B32A32_UINT:
636 case PIPE_FORMAT_R16G16B16A16_UINT:
637 case PIPE_FORMAT_R10G10B10A2_UINT:
638 case PIPE_FORMAT_R8G8B8A8_UINT:
639 case PIPE_FORMAT_R32G32_UINT:
640 case PIPE_FORMAT_R16G16_UINT:
641 case PIPE_FORMAT_R8G8_UINT:
642 case PIPE_FORMAT_R32_UINT:
643 case PIPE_FORMAT_R16_UINT:
644 case PIPE_FORMAT_R8_UINT:
645 case PIPE_FORMAT_R32G32B32A32_SINT:
646 case PIPE_FORMAT_R16G16B16A16_SINT:
647 case PIPE_FORMAT_R8G8B8A8_SINT:
648 case PIPE_FORMAT_R32G32_SINT:
649 case PIPE_FORMAT_R16G16_SINT:
650 case PIPE_FORMAT_R8G8_SINT:
651 case PIPE_FORMAT_R32_SINT:
652 case PIPE_FORMAT_R16_SINT:
653 case PIPE_FORMAT_R8_SINT:
654 case PIPE_FORMAT_R16G16B16A16_UNORM:
655 case PIPE_FORMAT_R10G10B10A2_UNORM:
656 case PIPE_FORMAT_R8G8B8A8_UNORM:
657 case PIPE_FORMAT_R16G16_UNORM:
658 case PIPE_FORMAT_R8G8_UNORM:
659 case PIPE_FORMAT_R16_UNORM:
660 case PIPE_FORMAT_R8_UNORM:
661 case PIPE_FORMAT_R16G16B16A16_SNORM:
662 case PIPE_FORMAT_R8G8B8A8_SNORM:
663 case PIPE_FORMAT_R16G16_SNORM:
664 case PIPE_FORMAT_R8G8_SNORM:
665 case PIPE_FORMAT_R16_SNORM:
666 case PIPE_FORMAT_R8_SNORM:
667 case PIPE_FORMAT_B8G8R8A8_UNORM:
668 case PIPE_FORMAT_A8_UNORM:
669 return true;
670 default:
671 return false;
672 }
673 }
674
675
676 /**
677 * Query format support for creating a texture, drawing surface, etc.
678 * \param format the format to test
679 * \param type one of PIPE_TEXTURE, PIPE_SURFACE
680 */
681 static bool
llvmpipe_is_format_supported(struct pipe_screen * _screen,enum pipe_format format,enum pipe_texture_target target,unsigned sample_count,unsigned storage_sample_count,unsigned bind)682 llvmpipe_is_format_supported(struct pipe_screen *_screen,
683 enum pipe_format format,
684 enum pipe_texture_target target,
685 unsigned sample_count,
686 unsigned storage_sample_count,
687 unsigned bind)
688 {
689 struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
690 struct sw_winsys *winsys = screen->winsys;
691 const struct util_format_description *format_desc =
692 util_format_description(format);
693
694 assert(target == PIPE_BUFFER ||
695 target == PIPE_TEXTURE_1D ||
696 target == PIPE_TEXTURE_1D_ARRAY ||
697 target == PIPE_TEXTURE_2D ||
698 target == PIPE_TEXTURE_2D_ARRAY ||
699 target == PIPE_TEXTURE_RECT ||
700 target == PIPE_TEXTURE_3D ||
701 target == PIPE_TEXTURE_CUBE ||
702 target == PIPE_TEXTURE_CUBE_ARRAY);
703
704 if (sample_count != 0 && sample_count != 1 && sample_count != 4)
705 return false;
706
707 if (bind & (PIPE_BIND_RENDER_TARGET | PIPE_BIND_SHADER_IMAGE))
708 if (!lp_storage_render_image_format_supported(format))
709 return false;
710
711 if (bind & PIPE_BIND_SHADER_IMAGE) {
712 if (!lp_storage_image_format_supported(format))
713 return false;
714 }
715
716 if ((bind & (PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW)) &&
717 ((bind & PIPE_BIND_DISPLAY_TARGET) == 0)) {
718 /* Disable all 3-channel formats, where channel size != 32 bits.
719 * In some cases we run into crashes (in generate_unswizzled_blend()),
720 * for 3-channel RGB16 variants, there was an apparent LLVM bug.
721 * In any case, disabling the shallower 3-channel formats avoids a
722 * number of issues with GL_ARB_copy_image support.
723 */
724 if (format_desc->is_array &&
725 format_desc->nr_channels == 3 &&
726 format_desc->block.bits != 96) {
727 return false;
728 }
729
730 /* Disable 64-bit integer formats for RT/samplers.
731 * VK CTS crashes with these and they don't make much sense.
732 */
733 int c = util_format_get_first_non_void_channel(format_desc->format);
734 if (c >= 0) {
735 if (format_desc->channel[c].pure_integer &&
736 format_desc->channel[c].size == 64)
737 return false;
738 }
739
740 }
741
742 if (!(bind & PIPE_BIND_VERTEX_BUFFER) &&
743 util_format_is_scaled(format))
744 return false;
745
746 if (bind & PIPE_BIND_DISPLAY_TARGET) {
747 if (!winsys->is_displaytarget_format_supported(winsys, bind, format))
748 return false;
749 }
750
751 if (bind & PIPE_BIND_DEPTH_STENCIL) {
752 if (format_desc->layout != UTIL_FORMAT_LAYOUT_PLAIN)
753 return false;
754
755 if (format_desc->colorspace != UTIL_FORMAT_COLORSPACE_ZS)
756 return false;
757 }
758
759 if (format_desc->layout == UTIL_FORMAT_LAYOUT_ASTC ||
760 format_desc->layout == UTIL_FORMAT_LAYOUT_ATC) {
761 /* Software decoding is not hooked up. */
762 return false;
763 }
764
765 if (format_desc->layout == UTIL_FORMAT_LAYOUT_ETC &&
766 format != PIPE_FORMAT_ETC1_RGB8)
767 return false;
768
769 /* planar not supported natively */
770 if ((format_desc->layout == UTIL_FORMAT_LAYOUT_SUBSAMPLED ||
771 format_desc->layout == UTIL_FORMAT_LAYOUT_PLANAR2 ||
772 format_desc->layout == UTIL_FORMAT_LAYOUT_PLANAR3) &&
773 target == PIPE_BUFFER)
774 return false;
775
776 if (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_YUV) {
777 if (format == PIPE_FORMAT_UYVY ||
778 format == PIPE_FORMAT_YUYV ||
779 format == PIPE_FORMAT_NV12)
780 return true;
781 return false;
782 }
783
784 /*
785 * Everything can be supported by u_format
786 * (those without fetch_rgba_float might be not but shouldn't hit that)
787 */
788
789 return true;
790 }
791
792
793 static void
llvmpipe_flush_frontbuffer(struct pipe_screen * _screen,struct pipe_context * _pipe,struct pipe_resource * resource,unsigned level,unsigned layer,void * context_private,unsigned nboxes,struct pipe_box * sub_box)794 llvmpipe_flush_frontbuffer(struct pipe_screen *_screen,
795 struct pipe_context *_pipe,
796 struct pipe_resource *resource,
797 unsigned level, unsigned layer,
798 void *context_private,
799 unsigned nboxes,
800 struct pipe_box *sub_box)
801 {
802 struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
803 struct sw_winsys *winsys = screen->winsys;
804 struct llvmpipe_resource *texture = llvmpipe_resource(resource);
805
806 assert(texture->dt);
807
808 if (texture->dt) {
809 if (_pipe)
810 llvmpipe_flush_resource(_pipe, resource, 0, true, true,
811 false, "frontbuffer");
812 winsys->displaytarget_display(winsys, texture->dt,
813 context_private, nboxes, sub_box);
814 }
815 }
816
817
818 static void
llvmpipe_destroy_screen(struct pipe_screen * _screen)819 llvmpipe_destroy_screen(struct pipe_screen *_screen)
820 {
821 struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
822
823 if (screen->cs_tpool)
824 lp_cs_tpool_destroy(screen->cs_tpool);
825
826 if (screen->rast)
827 lp_rast_destroy(screen->rast);
828
829 lp_jit_screen_cleanup(screen);
830
831 disk_cache_destroy(screen->disk_shader_cache);
832
833 glsl_type_singleton_decref();
834
835 #if defined(HAVE_LIBDRM) && defined(HAVE_LINUX_UDMABUF_H)
836 if (screen->udmabuf_fd != -1)
837 close(screen->udmabuf_fd);
838 #endif
839
840 #if DETECT_OS_LINUX
841 util_vma_heap_finish(&screen->mem_heap);
842
843 close(screen->fd_mem_alloc);
844 mtx_destroy(&screen->mem_mutex);
845 #endif
846 mtx_destroy(&screen->rast_mutex);
847 mtx_destroy(&screen->cs_mutex);
848 FREE(screen);
849 }
850
851
852 /**
853 * Fence reference counting.
854 */
855 static void
llvmpipe_fence_reference(struct pipe_screen * screen,struct pipe_fence_handle ** ptr,struct pipe_fence_handle * fence)856 llvmpipe_fence_reference(struct pipe_screen *screen,
857 struct pipe_fence_handle **ptr,
858 struct pipe_fence_handle *fence)
859 {
860 struct lp_fence **old = (struct lp_fence **) ptr;
861 struct lp_fence *f = (struct lp_fence *) fence;
862
863 lp_fence_reference(old, f);
864 }
865
866
867 /**
868 * Wait for the fence to finish.
869 */
870 static bool
llvmpipe_fence_finish(struct pipe_screen * screen,struct pipe_context * ctx,struct pipe_fence_handle * fence_handle,uint64_t timeout)871 llvmpipe_fence_finish(struct pipe_screen *screen,
872 struct pipe_context *ctx,
873 struct pipe_fence_handle *fence_handle,
874 uint64_t timeout)
875 {
876 struct lp_fence *f = (struct lp_fence *) fence_handle;
877
878 if (!timeout)
879 return lp_fence_signalled(f);
880
881 if (!lp_fence_signalled(f)) {
882 if (timeout != OS_TIMEOUT_INFINITE)
883 return lp_fence_timedwait(f, timeout);
884
885 lp_fence_wait(f);
886 }
887 return true;
888 }
889
890
891 static void
update_cache_sha1_cpu(struct mesa_sha1 * ctx)892 update_cache_sha1_cpu(struct mesa_sha1 *ctx)
893 {
894 const struct util_cpu_caps_t *cpu_caps = util_get_cpu_caps();
895 /*
896 * Don't need the cpu cache affinity stuff. The rest
897 * is contained in first 5 dwords.
898 */
899 STATIC_ASSERT(offsetof(struct util_cpu_caps_t, num_L3_caches)
900 == 5 * sizeof(uint32_t));
901 _mesa_sha1_update(ctx, cpu_caps, 5 * sizeof(uint32_t));
902 }
903
904
905 static void
lp_disk_cache_create(struct llvmpipe_screen * screen)906 lp_disk_cache_create(struct llvmpipe_screen *screen)
907 {
908 struct mesa_sha1 ctx;
909 unsigned gallivm_perf = gallivm_get_perf_flags();
910 unsigned char sha1[20];
911 char cache_id[20 * 2 + 1];
912 _mesa_sha1_init(&ctx);
913
914 if (!disk_cache_get_function_identifier(lp_disk_cache_create, &ctx) ||
915 !disk_cache_get_function_identifier(LLVMLinkInMCJIT, &ctx))
916 return;
917
918 _mesa_sha1_update(&ctx, &gallivm_perf, sizeof(gallivm_perf));
919 update_cache_sha1_cpu(&ctx);
920 _mesa_sha1_final(&ctx, sha1);
921 mesa_bytes_to_hex(cache_id, sha1, 20);
922
923 screen->disk_shader_cache = disk_cache_create("llvmpipe", cache_id, 0);
924 }
925
926
927 static struct disk_cache *
lp_get_disk_shader_cache(struct pipe_screen * _screen)928 lp_get_disk_shader_cache(struct pipe_screen *_screen)
929 {
930 struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
931
932 return screen->disk_shader_cache;
933 }
934
935 static int
llvmpipe_screen_get_fd(struct pipe_screen * _screen)936 llvmpipe_screen_get_fd(struct pipe_screen *_screen)
937 {
938 struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
939 struct sw_winsys *winsys = screen->winsys;
940
941 if (winsys->get_fd)
942 return winsys->get_fd(winsys);
943 else
944 return -1;
945 }
946
947
948 void
lp_disk_cache_find_shader(struct llvmpipe_screen * screen,struct lp_cached_code * cache,unsigned char ir_sha1_cache_key[20])949 lp_disk_cache_find_shader(struct llvmpipe_screen *screen,
950 struct lp_cached_code *cache,
951 unsigned char ir_sha1_cache_key[20])
952 {
953 unsigned char sha1[CACHE_KEY_SIZE];
954
955 if (!screen->disk_shader_cache)
956 return;
957 disk_cache_compute_key(screen->disk_shader_cache, ir_sha1_cache_key,
958 20, sha1);
959
960 size_t binary_size;
961 uint8_t *buffer = disk_cache_get(screen->disk_shader_cache,
962 sha1, &binary_size);
963 if (!buffer) {
964 cache->data_size = 0;
965 return;
966 }
967 cache->data_size = binary_size;
968 cache->data = buffer;
969 }
970
971
972 void
lp_disk_cache_insert_shader(struct llvmpipe_screen * screen,struct lp_cached_code * cache,unsigned char ir_sha1_cache_key[20])973 lp_disk_cache_insert_shader(struct llvmpipe_screen *screen,
974 struct lp_cached_code *cache,
975 unsigned char ir_sha1_cache_key[20])
976 {
977 unsigned char sha1[CACHE_KEY_SIZE];
978
979 if (!screen->disk_shader_cache || !cache->data_size || cache->dont_cache)
980 return;
981 disk_cache_compute_key(screen->disk_shader_cache, ir_sha1_cache_key,
982 20, sha1);
983 disk_cache_put(screen->disk_shader_cache, sha1, cache->data,
984 cache->data_size, NULL);
985 }
986
987
988 bool
llvmpipe_screen_late_init(struct llvmpipe_screen * screen)989 llvmpipe_screen_late_init(struct llvmpipe_screen *screen)
990 {
991 bool ret = true;
992 mtx_lock(&screen->late_mutex);
993
994 if (screen->late_init_done)
995 goto out;
996
997 screen->rast = lp_rast_create(screen->num_threads);
998 if (!screen->rast) {
999 ret = false;
1000 goto out;
1001 }
1002
1003 screen->cs_tpool = lp_cs_tpool_create(screen->num_threads);
1004 if (!screen->cs_tpool) {
1005 lp_rast_destroy(screen->rast);
1006 ret = false;
1007 goto out;
1008 }
1009
1010 if (!lp_jit_screen_init(screen)) {
1011 ret = false;
1012 goto out;
1013 }
1014
1015 lp_build_init(); /* get lp_native_vector_width initialised */
1016
1017 lp_disk_cache_create(screen);
1018 screen->late_init_done = true;
1019 out:
1020 mtx_unlock(&screen->late_mutex);
1021 return ret;
1022 }
1023
1024
1025 /**
1026 * Create a new pipe_screen object
1027 * Note: we're not presently subclassing pipe_screen (no llvmpipe_screen).
1028 */
1029 struct pipe_screen *
llvmpipe_create_screen(struct sw_winsys * winsys)1030 llvmpipe_create_screen(struct sw_winsys *winsys)
1031 {
1032 struct llvmpipe_screen *screen;
1033
1034 glsl_type_singleton_init_or_ref();
1035
1036 LP_DEBUG = debug_get_flags_option("LP_DEBUG", lp_debug_flags, 0 );
1037
1038 LP_PERF = debug_get_flags_option("LP_PERF", lp_perf_flags, 0 );
1039
1040 screen = CALLOC_STRUCT(llvmpipe_screen);
1041 if (!screen)
1042 return NULL;
1043
1044 screen->winsys = winsys;
1045
1046 screen->base.destroy = llvmpipe_destroy_screen;
1047
1048 screen->base.get_name = llvmpipe_get_name;
1049 screen->base.get_vendor = llvmpipe_get_vendor;
1050 screen->base.get_device_vendor = llvmpipe_get_vendor; // TODO should be the CPU vendor
1051 screen->base.get_screen_fd = llvmpipe_screen_get_fd;
1052 screen->base.get_shader_param = llvmpipe_get_shader_param;
1053 screen->base.get_compute_param = llvmpipe_get_compute_param;
1054 screen->base.get_compiler_options = llvmpipe_get_compiler_options;
1055 screen->base.is_format_supported = llvmpipe_is_format_supported;
1056
1057 screen->base.context_create = llvmpipe_create_context;
1058 screen->base.flush_frontbuffer = llvmpipe_flush_frontbuffer;
1059 screen->base.fence_reference = llvmpipe_fence_reference;
1060 screen->base.fence_finish = llvmpipe_fence_finish;
1061
1062 screen->base.get_timestamp = u_default_get_timestamp;
1063
1064 screen->base.query_memory_info = util_sw_query_memory_info;
1065
1066 screen->base.get_driver_uuid = llvmpipe_get_driver_uuid;
1067 screen->base.get_device_uuid = llvmpipe_get_device_uuid;
1068
1069 screen->base.finalize_nir = llvmpipe_finalize_nir;
1070
1071 screen->base.get_disk_shader_cache = lp_get_disk_shader_cache;
1072 llvmpipe_init_screen_resource_funcs(&screen->base);
1073
1074 screen->allow_cl = !!getenv("LP_CL");
1075 screen->num_threads = util_get_cpu_caps()->nr_cpus > 1
1076 ? util_get_cpu_caps()->nr_cpus : 0;
1077 screen->num_threads = debug_get_num_option("LP_NUM_THREADS",
1078 screen->num_threads);
1079 screen->num_threads = MIN2(screen->num_threads, LP_MAX_THREADS);
1080
1081 #if defined(HAVE_LIBDRM) && defined(HAVE_LINUX_UDMABUF_H)
1082 screen->udmabuf_fd = open("/dev/udmabuf", O_RDWR);
1083 llvmpipe_init_screen_fence_funcs(&screen->base);
1084 #endif
1085
1086 uint64_t alignment;
1087 if (!os_get_page_size(&alignment))
1088 alignment = 256;
1089
1090 #if DETECT_OS_LINUX
1091 (void) mtx_init(&screen->mem_mutex, mtx_plain);
1092
1093 util_vma_heap_init(&screen->mem_heap, alignment, UINT64_MAX - alignment);
1094 screen->mem_heap.alloc_high = false;
1095 screen->fd_mem_alloc = os_create_anonymous_file(0, "allocation fd");
1096 #endif
1097
1098 llvmpipe_init_screen_caps(&screen->base);
1099
1100 snprintf(screen->renderer_string, sizeof(screen->renderer_string),
1101 "llvmpipe (LLVM " MESA_LLVM_VERSION_STRING ", %u bits)",
1102 lp_build_init_native_width() );
1103
1104 list_inithead(&screen->ctx_list);
1105 (void) mtx_init(&screen->ctx_mutex, mtx_plain);
1106 (void) mtx_init(&screen->cs_mutex, mtx_plain);
1107 (void) mtx_init(&screen->rast_mutex, mtx_plain);
1108
1109 (void) mtx_init(&screen->late_mutex, mtx_plain);
1110
1111 return &screen->base;
1112 }
1113