From 6dddd184803da5f67f69e7c243dbb596b4dd4b9d Mon Sep 17 00:00:00 2001 From: José Fonseca Date: Thu, 12 Jul 2012 20:47:20 +0100 Subject: draw,gallivm: Fix draw_get_shader_param. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Use LLVM limits when LLVM is being used, instead of TGSI limits - Provide draw_get_shader_param_no_llvm for when llvm is never used (softpipe) - Eliminate several of the hacks around draw shader caps in several drivers Unfortunately the hack for PIPE_MAX_VERTEX_SAMPLERS is still necessary. Reviewed-by: Marek Olšák --- src/gallium/auxiliary/draw/draw_context.c | 41 +++++++++++++++++++ src/gallium/auxiliary/draw/draw_context.h | 16 +++----- src/gallium/auxiliary/gallivm/lp_bld_limits.h | 58 ++++++++++++++++++++++++++- src/gallium/drivers/i915/i915_screen.c | 2 - src/gallium/drivers/llvmpipe/lp_screen.c | 6 +-- src/gallium/drivers/softpipe/sp_screen.c | 18 +++------ 6 files changed, 110 insertions(+), 31 deletions(-) diff --git a/src/gallium/auxiliary/draw/draw_context.c b/src/gallium/auxiliary/draw/draw_context.c index 2eae204ff2c..20260c1abbf 100644 --- a/src/gallium/auxiliary/draw/draw_context.c +++ b/src/gallium/auxiliary/draw/draw_context.c @@ -42,6 +42,7 @@ #if HAVE_LLVM #include "gallivm/lp_bld_init.h" +#include "gallivm/lp_bld_limits.h" #include "draw_llvm.h" static boolean @@ -830,3 +831,43 @@ draw_set_mapped_texture(struct draw_context *draw, row_stride, img_stride, data); #endif } + +/** + * XXX: Results for PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS because there are two + * different ways of setting textures, and drivers typically only support one. + */ +int +draw_get_shader_param_no_llvm(unsigned shader, enum pipe_shader_cap param) +{ + switch(shader) { + case PIPE_SHADER_VERTEX: + case PIPE_SHADER_GEOMETRY: + return tgsi_exec_get_shader_param(param); + default: + return 0; + } +} + +/** + * XXX: Results for PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS because there are two + * different ways of setting textures, and drivers typically only support one. + */ +int +draw_get_shader_param(unsigned shader, enum pipe_shader_cap param) +{ + +#ifdef HAVE_LLVM + if (draw_get_option_use_llvm()) { + switch(shader) { + case PIPE_SHADER_VERTEX: + case PIPE_SHADER_GEOMETRY: + return gallivm_get_shader_param(param); + default: + return 0; + } + } +#endif + + return draw_get_shader_param_no_llvm(shader, param); +} + diff --git a/src/gallium/auxiliary/draw/draw_context.h b/src/gallium/auxiliary/draw/draw_context.h index 4cd0caf3296..852cbc3da13 100644 --- a/src/gallium/auxiliary/draw/draw_context.h +++ b/src/gallium/auxiliary/draw/draw_context.h @@ -277,16 +277,10 @@ boolean draw_need_pipeline(const struct draw_context *draw, const struct pipe_rasterizer_state *rasterizer, unsigned prim ); -static INLINE int -draw_get_shader_param(unsigned shader, enum pipe_shader_cap param) -{ - switch(shader) { - case PIPE_SHADER_VERTEX: - case PIPE_SHADER_GEOMETRY: - return tgsi_exec_get_shader_param(param); - default: - return 0; - } -} +int +draw_get_shader_param(unsigned shader, enum pipe_shader_cap param); + +int +draw_get_shader_param_no_llvm(unsigned shader, enum pipe_shader_cap param); #endif /* DRAW_CONTEXT_H */ diff --git a/src/gallium/auxiliary/gallivm/lp_bld_limits.h b/src/gallium/auxiliary/gallivm/lp_bld_limits.h index 2dbb7cee29b..905070e7ae8 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_limits.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_limits.h @@ -1,6 +1,6 @@ /************************************************************************** * - * Copyright 2010 VMware, Inc. + * Copyright 2010-2012 VMware, Inc. * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a @@ -29,6 +29,13 @@ #ifndef LP_BLD_LIMITS_H_ #define LP_BLD_LIMITS_H_ + +#include + +#include "pipe/p_state.h" +#include "pipe/p_defines.h" + + /* * TGSI translation limits. * @@ -57,4 +64,53 @@ */ #define LP_MAX_TGSI_LOOP_ITERATIONS 65535 + +/** + * Some of these limits are actually infinite (i.e., only limited by available + * memory), however advertising INT_MAX would cause some test problems to + * actually try to allocate the maximum and run out of memory and crash. So + * stick with something reasonable here. + */ +static INLINE int +gallivm_get_shader_param(enum pipe_shader_cap param) +{ + switch(param) { + case PIPE_SHADER_CAP_MAX_INSTRUCTIONS: + case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS: + case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS: + case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS: + return 1 * 1024 * 1024; + case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH: + return LP_MAX_TGSI_NESTING; + case PIPE_SHADER_CAP_MAX_INPUTS: + return PIPE_MAX_SHADER_INPUTS; + case PIPE_SHADER_CAP_MAX_CONSTS: + return 16 * 2024; + case PIPE_SHADER_CAP_MAX_CONST_BUFFERS: + return PIPE_MAX_CONSTANT_BUFFERS; + case PIPE_SHADER_CAP_MAX_TEMPS: + return LP_MAX_TGSI_TEMPS; + case PIPE_SHADER_CAP_MAX_ADDRS: + return LP_MAX_TGSI_ADDRS; + case PIPE_SHADER_CAP_MAX_PREDS: + return LP_MAX_TGSI_PREDS; + case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED: + return 1; + case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR: + case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR: + case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR: + case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR: + return 1; + case PIPE_SHADER_CAP_SUBROUTINES: + return 1; + case PIPE_SHADER_CAP_INTEGERS: + return 1; + case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS: + return PIPE_MAX_SAMPLERS; + default: + return 0; + } +} + + #endif /* LP_BLD_LIMITS_H_ */ diff --git a/src/gallium/drivers/i915/i915_screen.c b/src/gallium/drivers/i915/i915_screen.c index 88c826085c1..35b343e0de8 100644 --- a/src/gallium/drivers/i915/i915_screen.c +++ b/src/gallium/drivers/i915/i915_screen.c @@ -110,8 +110,6 @@ i915_get_shader_param(struct pipe_screen *screen, unsigned shader, enum pipe_sha return PIPE_MAX_VERTEX_SAMPLERS; else return 0; - case PIPE_SHADER_CAP_INTEGERS: - return 1; default: return draw_get_shader_param(shader, cap); } diff --git a/src/gallium/drivers/llvmpipe/lp_screen.c b/src/gallium/drivers/llvmpipe/lp_screen.c index 930a9ee16af..61aa1925eec 100644 --- a/src/gallium/drivers/llvmpipe/lp_screen.c +++ b/src/gallium/drivers/llvmpipe/lp_screen.c @@ -222,10 +222,8 @@ llvmpipe_get_shader_param(struct pipe_screen *screen, unsigned shader, enum pipe { case PIPE_SHADER_FRAGMENT: switch (param) { - case PIPE_SHADER_CAP_INTEGERS: - return 0; default: - return tgsi_exec_get_shader_param(param); + return gallivm_get_shader_param(param); } case PIPE_SHADER_VERTEX: case PIPE_SHADER_GEOMETRY: @@ -239,8 +237,6 @@ llvmpipe_get_shader_param(struct pipe_screen *screen, unsigned shader, enum pipe return PIPE_MAX_VERTEX_SAMPLERS; else return 0; - case PIPE_SHADER_CAP_INTEGERS: - return 0; default: return draw_get_shader_param(shader, param); } diff --git a/src/gallium/drivers/softpipe/sp_screen.c b/src/gallium/drivers/softpipe/sp_screen.c index 684f0358955..5588611edcf 100644 --- a/src/gallium/drivers/softpipe/sp_screen.c +++ b/src/gallium/drivers/softpipe/sp_screen.c @@ -177,9 +177,7 @@ softpipe_get_param(struct pipe_screen *screen, enum pipe_cap param) static int softpipe_get_shader_param(struct pipe_screen *screen, unsigned shader, enum pipe_shader_cap param) { -#ifdef HAVE_LLVM struct softpipe_screen *sp_screen = softpipe_screen(screen); -#endif switch(shader) { case PIPE_SHADER_FRAGMENT: @@ -188,20 +186,16 @@ softpipe_get_shader_param(struct pipe_screen *screen, unsigned shader, enum pipe case PIPE_SHADER_GEOMETRY: switch (param) { case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS: -#ifdef HAVE_LLVM if (sp_screen->use_llvm) /* Softpipe doesn't yet know how to tell draw/llvm about textures */ return 0; -#endif - return PIPE_MAX_VERTEX_SAMPLERS; - case PIPE_SHADER_CAP_INTEGERS: -#ifdef HAVE_LLVM /* gallivm doesn't support integers yet */ - if (sp_screen->use_llvm) - return 0; -#endif - /* fallthrough */ + else + return PIPE_MAX_VERTEX_SAMPLERS; default: - return draw_get_shader_param(shader, param); + if (sp_screen->use_llvm) + return draw_get_shader_param(shader, param); + else + return draw_get_shader_param_no_llvm(shader, param); } default: return 0; -- cgit v1.2.3