*
* @returns 0 for success, 1 for failure
*/
-unsigned si_llvm_compile(LLVMModuleRef M, struct ac_shader_binary *binary,
+unsigned si_llvm_compile(LLVMModuleRef M, struct si_shader_binary *binary,
struct ac_llvm_compiler *compiler,
struct pipe_debug_callback *debug,
- bool less_optimized)
+ bool less_optimized, unsigned wave_size)
{
- struct ac_compiler_passes *passes =
- less_optimized && compiler->low_opt_passes ?
- compiler->low_opt_passes : compiler->passes;
+ struct ac_compiler_passes *passes = compiler->passes;
+
+ if (wave_size == 32)
+ passes = compiler->passes_wave32;
+ else if (less_optimized && compiler->low_opt_passes)
+ passes = compiler->low_opt_passes;
+
struct si_llvm_diagnostics diag;
LLVMContextRef llvm_ctx;
LLVMContextSetDiagnosticHandler(llvm_ctx, si_diagnostic_handler, &diag);
/* Compile IR. */
- if (!ac_compile_module_to_binary(passes, M, binary))
+ if (!ac_compile_module_to_elf(passes, M, (char **)&binary->elf_buffer,
+ &binary->elf_size))
diag.retval = 1;
if (diag.retval != 0)
return diag.retval;
}
+void si_shader_binary_clean(struct si_shader_binary *binary)
+{
+ free((void *)binary->elf_buffer);
+ binary->elf_buffer = NULL;
+
+ free(binary->llvm_ir_string);
+ binary->llvm_ir_string = NULL;
+}
+
LLVMTypeRef tgsi2llvmtype(struct lp_build_tgsi_context *bld_base,
enum tgsi_opcode_type type)
{
emit_array_fetch(struct lp_build_tgsi_context *bld_base,
unsigned File, enum tgsi_opcode_type type,
struct tgsi_declaration_range range,
- unsigned swizzle)
+ unsigned swizzle_in)
{
struct si_shader_context *ctx = si_shader_context(bld_base);
unsigned i, size = range.Last - range.First + 1;
LLVMTypeRef vec = LLVMVectorType(tgsi2llvmtype(bld_base, type), size);
LLVMValueRef result = LLVMGetUndef(vec);
-
+ unsigned swizzle = swizzle_in;
struct tgsi_full_src_register tmp_reg = {};
tmp_reg.Register.File = File;
+ if (tgsi_type_is_64bit(type))
+ swizzle |= (swizzle_in + 1) << 16;
for (i = 0; i < size; ++i) {
tmp_reg.Register.Index = i + range.First;
+
LLVMValueRef temp = si_llvm_emit_fetch(bld_base, &tmp_reg, type, swizzle);
result = LLVMBuildInsertElement(ctx->ac.builder, result, temp,
LLVMConstInt(ctx->i32, i, 0), "array_vector");
LLVMValueRef si_llvm_emit_fetch(struct lp_build_tgsi_context *bld_base,
const struct tgsi_full_src_register *reg,
enum tgsi_opcode_type type,
- unsigned swizzle)
+ unsigned swizzle_in)
{
struct si_shader_context *ctx = si_shader_context(bld_base);
LLVMBuilderRef builder = ctx->ac.builder;
LLVMValueRef result = NULL, ptr, ptr2;
+ unsigned swizzle = swizzle_in & 0xffff;
- if (swizzle == ~0) {
+ if (swizzle_in == ~0) {
LLVMValueRef values[TGSI_NUM_CHANNELS];
unsigned chan;
for (chan = 0; chan < TGSI_NUM_CHANNELS; chan++) {
ctx->imms[reg->Register.Index * TGSI_NUM_CHANNELS + swizzle],
ctx->i32_0);
result = LLVMConstInsertElement(result,
- ctx->imms[reg->Register.Index * TGSI_NUM_CHANNELS + swizzle + 1],
+ ctx->imms[reg->Register.Index * TGSI_NUM_CHANNELS + (swizzle_in >> 16)],
ctx->i32_1);
return LLVMConstBitCast(result, ctype);
} else {
if (tgsi_type_is_64bit(type)) {
ptr = result;
- ptr2 = input[swizzle + 1];
+ ptr2 = input[swizzle_in >> 16];
return si_llvm_emit_fetch_64bit(bld_base, tgsi2llvmtype(bld_base, type),
ptr, ptr2);
}
return LLVMGetUndef(tgsi2llvmtype(bld_base, type));
ptr = ctx->temps[reg->Register.Index * TGSI_NUM_CHANNELS + swizzle];
if (tgsi_type_is_64bit(type)) {
- ptr2 = ctx->temps[reg->Register.Index * TGSI_NUM_CHANNELS + swizzle + 1];
+ ptr2 = ctx->temps[reg->Register.Index * TGSI_NUM_CHANNELS + (swizzle_in >> 16)];
return si_llvm_emit_fetch_64bit(bld_base, tgsi2llvmtype(bld_base, type),
LLVMBuildLoad(builder, ptr, ""),
LLVMBuildLoad(builder, ptr2, ""));
case TGSI_FILE_OUTPUT:
ptr = get_output_ptr(bld_base, reg->Register.Index, swizzle);
if (tgsi_type_is_64bit(type)) {
- ptr2 = get_output_ptr(bld_base, reg->Register.Index, swizzle + 1);
+ ptr2 = get_output_ptr(bld_base, reg->Register.Index, (swizzle_in >> 16));
return si_llvm_emit_fetch_64bit(bld_base, tgsi2llvmtype(bld_base, type),
LLVMBuildLoad(builder, ptr, ""),
LLVMBuildLoad(builder, ptr2, ""));
static LLVMValueRef fetch_system_value(struct lp_build_tgsi_context *bld_base,
const struct tgsi_full_src_register *reg,
enum tgsi_opcode_type type,
- unsigned swizzle)
+ unsigned swizzle_in)
{
struct si_shader_context *ctx = si_shader_context(bld_base);
LLVMBuilderRef builder = ctx->ac.builder;
LLVMValueRef cval = ctx->system_values[reg->Register.Index];
+ unsigned swizzle = swizzle_in & 0xffff;
if (tgsi_type_is_64bit(type)) {
LLVMValueRef lo, hi;
lo = LLVMBuildExtractElement(
builder, cval, LLVMConstInt(ctx->i32, swizzle, 0), "");
hi = LLVMBuildExtractElement(
- builder, cval, LLVMConstInt(ctx->i32, swizzle + 1, 0), "");
+ builder, cval, LLVMConstInt(ctx->i32, (swizzle_in >> 16), 0), "");
return si_llvm_emit_fetch_64bit(bld_base, tgsi2llvmtype(bld_base, type),
lo, hi);
}
if (!array_alloca) {
for (i = 0; i < decl_size; ++i) {
-#ifdef DEBUG
+#ifndef NDEBUG
snprintf(name, sizeof(name), "TEMP%d.%c",
first + i / 4, "xyzw"[i % 4]);
#endif
for (i = 0; i < decl_size; ++i) {
LLVMValueRef ptr;
if (writemask & (1 << (i % 4))) {
-#ifdef DEBUG
+#ifndef NDEBUG
snprintf(name, sizeof(name), "TEMP%d.%c",
first + i / 4, "xyzw"[i % 4]);
#endif
if (ctx->outputs[idx][0])
continue;
for (chan = 0; chan < TGSI_NUM_CHANNELS; chan++) {
-#ifdef DEBUG
+#ifndef NDEBUG
snprintf(name, sizeof(name), "OUT%d.%c",
idx, "xyzw"[chan % 4]);
#endif
void si_llvm_context_init(struct si_shader_context *ctx,
struct si_screen *sscreen,
- struct ac_llvm_compiler *compiler)
+ struct ac_llvm_compiler *compiler,
+ unsigned wave_size,
+ unsigned ballot_mask_bits)
{
struct lp_type type;
ctx->screen = sscreen;
ctx->compiler = compiler;
- ac_llvm_context_init(&ctx->ac, sscreen->info.chip_class, sscreen->info.family);
- ctx->ac.module = ac_create_module(compiler->tm, ctx->ac.context);
-
- enum ac_float_mode float_mode =
- sscreen->debug_flags & DBG(UNSAFE_MATH) ?
- AC_FLOAT_MODE_UNSAFE_FP_MATH :
- AC_FLOAT_MODE_NO_SIGNED_ZEROS_FP_MATH;
- ctx->ac.builder = ac_create_builder(ctx->ac.context, float_mode);
+ ac_llvm_context_init(&ctx->ac, compiler, sscreen->info.chip_class,
+ sscreen->info.family,
+ AC_FLOAT_MODE_NO_SIGNED_ZEROS_FP_MATH,
+ wave_size, ballot_mask_bits);
ctx->gallivm.context = ctx->ac.context;
ctx->gallivm.module = ctx->ac.module;
bld_base->op_actions[TGSI_OPCODE_ENDIF].emit = endif_emit;
bld_base->op_actions[TGSI_OPCODE_ENDLOOP].emit = endloop_emit;
- si_shader_context_init_alu(&ctx->bld_base);
+ si_shader_context_init_alu(ctx);
si_shader_context_init_mem(ctx);
ctx->voidt = LLVMVoidTypeInContext(ctx->ac.context);
/* Set the context to a certain TGSI shader. Can be called repeatedly
* to change the shader. */
-void si_llvm_context_set_tgsi(struct si_shader_context *ctx,
- struct si_shader *shader)
+void si_llvm_context_set_ir(struct si_shader_context *ctx,
+ struct si_shader *shader)
{
- const struct tgsi_shader_info *info = NULL;
- const struct tgsi_token *tokens = NULL;
-
- if (shader && shader->selector) {
- info = &shader->selector->info;
- tokens = shader->selector->tokens;
- }
+ struct si_shader_selector *sel = shader->selector;
+ const struct tgsi_shader_info *info = &sel->info;
ctx->shader = shader;
- ctx->type = info ? info->processor : -1;
+ ctx->type = sel->type;
ctx->bld_base.info = info;
/* Clean up the old contents. */
ctx->temps = NULL;
ctx->temps_count = 0;
- if (!info)
- return;
-
ctx->num_const_buffers = util_last_bit(info->const_buffers_declared);
ctx->num_shader_buffers = util_last_bit(info->shader_buffers_declared);
ctx->num_samplers = util_last_bit(info->samplers_declared);
ctx->num_images = util_last_bit(info->images_declared);
- if (!tokens)
+ if (sel->nir)
return;
if (info->array_max[TGSI_FILE_TEMPORARY] > 0) {
ctx->temp_arrays = CALLOC(size, sizeof(ctx->temp_arrays[0]));
ctx->temp_array_allocas = CALLOC(size, sizeof(ctx->temp_array_allocas[0]));
- tgsi_scan_arrays(tokens, TGSI_FILE_TEMPORARY, size,
+ tgsi_scan_arrays(sel->tokens, TGSI_FILE_TEMPORARY, size,
ctx->temp_arrays);
}
if (info->file_max[TGSI_FILE_IMMEDIATE] >= 0) {
LLVMTypeRef main_fn_type, ret_type;
LLVMBasicBlockRef main_fn_body;
enum si_llvm_calling_convention call_conv;
- unsigned real_shader_type;
+ enum pipe_shader_type real_shader_type;
if (num_return_elems)
ret_type = LLVMStructTypeInContext(ctx->ac.context,
if (ctx->screen->info.chip_class >= GFX9) {
if (ctx->shader->key.as_ls)
real_shader_type = PIPE_SHADER_TESS_CTRL;
- else if (ctx->shader->key.as_es)
+ else if (ctx->shader->key.as_es || ctx->shader->key.as_ngg)
real_shader_type = PIPE_SHADER_GEOMETRY;
}