Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright 2011 Advanced Micro Devices, Inc.
  3.  *
  4.  * Permission is hereby granted, free of charge, to any person obtaining a
  5.  * copy of this software and associated documentation files (the "Software"),
  6.  * to deal in the Software without restriction, including without limitation
  7.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  8.  * and/or sell copies of the Software, and to permit persons to whom the
  9.  * Software is furnished to do so, subject to the following conditions:
  10.  *
  11.  * The above copyright notice and this permission notice (including the next
  12.  * paragraph) shall be included in all copies or substantial portions of the
  13.  * Software.
  14.  *
  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21.  * SOFTWARE.
  22.  *
  23.  * Authors: Tom Stellard <thomas.stellard@amd.com>
  24.  *
  25.  */
  26. #include "radeon_llvm.h"
  27.  
  28. #include "gallivm/lp_bld_const.h"
  29. #include "gallivm/lp_bld_gather.h"
  30. #include "gallivm/lp_bld_flow.h"
  31. #include "gallivm/lp_bld_init.h"
  32. #include "gallivm/lp_bld_intr.h"
  33. #include "gallivm/lp_bld_swizzle.h"
  34. #include "tgsi/tgsi_info.h"
  35. #include "tgsi/tgsi_parse.h"
  36. #include "util/u_math.h"
  37. #include "util/u_memory.h"
  38. #include "util/u_debug.h"
  39.  
  40. #include <llvm-c/Core.h>
  41. #include <llvm-c/Transforms/Scalar.h>
  42.  
  43. static struct radeon_llvm_loop * get_current_loop(struct radeon_llvm_context * ctx)
  44. {
  45.         return ctx->loop_depth > 0 ? ctx->loop + (ctx->loop_depth - 1) : NULL;
  46. }
  47.  
  48. static struct radeon_llvm_branch * get_current_branch(
  49.         struct radeon_llvm_context * ctx)
  50. {
  51.         return ctx->branch_depth > 0 ?
  52.                         ctx->branch + (ctx->branch_depth - 1) : NULL;
  53. }
  54.  
  55. unsigned radeon_llvm_reg_index_soa(unsigned index, unsigned chan)
  56. {
  57.  return (index * 4) + chan;
  58. }
  59.  
  60. static LLVMValueRef emit_swizzle(
  61.         struct lp_build_tgsi_context * bld_base,
  62.         LLVMValueRef value,
  63.         unsigned swizzle_x,
  64.         unsigned swizzle_y,
  65.         unsigned swizzle_z,
  66.         unsigned swizzle_w)
  67. {
  68.         LLVMValueRef swizzles[4];
  69.         LLVMTypeRef i32t =
  70.                 LLVMInt32TypeInContext(bld_base->base.gallivm->context);
  71.  
  72.         swizzles[0] = LLVMConstInt(i32t, swizzle_x, 0);
  73.         swizzles[1] = LLVMConstInt(i32t, swizzle_y, 0);
  74.         swizzles[2] = LLVMConstInt(i32t, swizzle_z, 0);
  75.         swizzles[3] = LLVMConstInt(i32t, swizzle_w, 0);
  76.  
  77.         return LLVMBuildShuffleVector(bld_base->base.gallivm->builder,
  78.                 value,
  79.                 LLVMGetUndef(LLVMTypeOf(value)),
  80.                 LLVMConstVector(swizzles, 4), "");
  81. }
  82.  
  83. static struct tgsi_declaration_range
  84. get_array_range(struct lp_build_tgsi_context *bld_base,
  85.                 unsigned File, const struct tgsi_ind_register *reg)
  86. {
  87.         struct radeon_llvm_context * ctx = radeon_llvm_context(bld_base);
  88.         if (File != TGSI_FILE_TEMPORARY || reg->ArrayID == 0 ||
  89.             reg->ArrayID > RADEON_LLVM_MAX_ARRAYS) {
  90.                 struct tgsi_declaration_range range;
  91.                 range.First = 0;
  92.                 range.Last = bld_base->info->file_max[File];
  93.                 return range;
  94.         }
  95.  
  96.         return ctx->arrays[reg->ArrayID - 1];
  97. }
  98.  
  99. static LLVMValueRef
  100. emit_array_index(
  101.         struct lp_build_tgsi_soa_context *bld,
  102.         const struct tgsi_ind_register *reg,
  103.         unsigned offset)
  104. {
  105.         struct gallivm_state * gallivm = bld->bld_base.base.gallivm;
  106.  
  107.         LLVMValueRef addr = LLVMBuildLoad(gallivm->builder, bld->addr[reg->Index][reg->Swizzle], "");
  108.         return LLVMBuildAdd(gallivm->builder, addr, lp_build_const_int32(gallivm, offset), "");
  109. }
  110.  
  111. static LLVMValueRef
  112. emit_fetch(
  113.         struct lp_build_tgsi_context *bld_base,
  114.         const struct tgsi_full_src_register *reg,
  115.         enum tgsi_opcode_type type,
  116.         unsigned swizzle);
  117.  
  118. static LLVMValueRef
  119. emit_array_fetch(
  120.         struct lp_build_tgsi_context *bld_base,
  121.         unsigned File, enum tgsi_opcode_type type,
  122.         struct tgsi_declaration_range range,
  123.         unsigned swizzle)
  124. {
  125.         struct lp_build_tgsi_soa_context *bld = lp_soa_context(bld_base);
  126.         struct gallivm_state * gallivm = bld->bld_base.base.gallivm;
  127.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  128.  
  129.         unsigned i, size = range.Last - range.First + 1;
  130.         LLVMTypeRef vec = LLVMVectorType(tgsi2llvmtype(bld_base, type), size);
  131.         LLVMValueRef result = LLVMGetUndef(vec);
  132.  
  133.         struct tgsi_full_src_register tmp_reg = {};
  134.         tmp_reg.Register.File = File;
  135.  
  136.         for (i = 0; i < size; ++i) {
  137.                 tmp_reg.Register.Index = i + range.First;
  138.                 LLVMValueRef temp = emit_fetch(bld_base, &tmp_reg, type, swizzle);
  139.                 result = LLVMBuildInsertElement(builder, result, temp,
  140.                         lp_build_const_int32(gallivm, i), "");
  141.         }
  142.         return result;
  143. }
  144.  
  145. static LLVMValueRef
  146. emit_fetch(
  147.         struct lp_build_tgsi_context *bld_base,
  148.         const struct tgsi_full_src_register *reg,
  149.         enum tgsi_opcode_type type,
  150.         unsigned swizzle)
  151. {
  152.         struct radeon_llvm_context * ctx = radeon_llvm_context(bld_base);
  153.         struct lp_build_tgsi_soa_context *bld = lp_soa_context(bld_base);
  154.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  155.         LLVMValueRef result, ptr;
  156.  
  157.         if (swizzle == ~0) {
  158.                 LLVMValueRef values[TGSI_NUM_CHANNELS];
  159.                 unsigned chan;
  160.                 for (chan = 0; chan < TGSI_NUM_CHANNELS; chan++) {
  161.                         values[chan] = emit_fetch(bld_base, reg, type, chan);
  162.                 }
  163.                 return lp_build_gather_values(bld_base->base.gallivm, values,
  164.                                               TGSI_NUM_CHANNELS);
  165.         }
  166.  
  167.         if (reg->Register.Indirect) {
  168.                 struct tgsi_declaration_range range = get_array_range(bld_base,
  169.                         reg->Register.File, &reg->Indirect);
  170.                 return LLVMBuildExtractElement(builder,
  171.                         emit_array_fetch(bld_base, reg->Register.File, type, range, swizzle),
  172.                         emit_array_index(bld, &reg->Indirect, reg->Register.Index - range.First),
  173.                         "");
  174.         }
  175.  
  176.         switch(reg->Register.File) {
  177.         case TGSI_FILE_IMMEDIATE: {
  178.                 LLVMTypeRef ctype = tgsi2llvmtype(bld_base, type);
  179.                 return LLVMConstBitCast(bld->immediates[reg->Register.Index][swizzle], ctype);
  180.         }
  181.  
  182.         case TGSI_FILE_INPUT:
  183.                 result = ctx->inputs[radeon_llvm_reg_index_soa(reg->Register.Index, swizzle)];
  184.                 break;
  185.  
  186.         case TGSI_FILE_TEMPORARY:
  187.                 ptr = lp_get_temp_ptr_soa(bld, reg->Register.Index, swizzle);
  188.                 result = LLVMBuildLoad(builder, ptr, "");
  189.                 break;
  190.  
  191.         case TGSI_FILE_OUTPUT:
  192.                 ptr = lp_get_output_ptr(bld, reg->Register.Index, swizzle);
  193.                 result = LLVMBuildLoad(builder, ptr, "");
  194.                 break;
  195.  
  196.         default:
  197.                 return LLVMGetUndef(tgsi2llvmtype(bld_base, type));
  198.         }
  199.  
  200.         return bitcast(bld_base, type, result);
  201. }
  202.  
  203. static LLVMValueRef fetch_system_value(
  204.         struct lp_build_tgsi_context * bld_base,
  205.         const struct tgsi_full_src_register *reg,
  206.         enum tgsi_opcode_type type,
  207.         unsigned swizzle)
  208. {
  209.         struct radeon_llvm_context * ctx = radeon_llvm_context(bld_base);
  210.         LLVMValueRef cval = ctx->system_values[reg->Register.Index];
  211.         return bitcast(bld_base, type, cval);
  212. }
  213.  
  214. static void emit_declaration(
  215.         struct lp_build_tgsi_context * bld_base,
  216.         const struct tgsi_full_declaration *decl)
  217. {
  218.         struct radeon_llvm_context * ctx = radeon_llvm_context(bld_base);
  219.         switch(decl->Declaration.File) {
  220.         case TGSI_FILE_ADDRESS:
  221.         {
  222.                  unsigned idx;
  223.                 for (idx = decl->Range.First; idx <= decl->Range.Last; idx++) {
  224.                         unsigned chan;
  225.                         for (chan = 0; chan < TGSI_NUM_CHANNELS; chan++) {
  226.                                  ctx->soa.addr[idx][chan] = lp_build_alloca(
  227.                                         &ctx->gallivm,
  228.                                         ctx->soa.bld_base.uint_bld.elem_type, "");
  229.                         }
  230.                 }
  231.                 break;
  232.         }
  233.  
  234.         case TGSI_FILE_TEMPORARY:
  235.                 if (decl->Declaration.Array && decl->Array.ArrayID <= RADEON_LLVM_MAX_ARRAYS)
  236.                         ctx->arrays[decl->Array.ArrayID - 1] = decl->Range;
  237.                 lp_emit_declaration_soa(bld_base, decl);
  238.                 break;
  239.  
  240.         case TGSI_FILE_INPUT:
  241.         {
  242.                 unsigned idx;
  243.                 for (idx = decl->Range.First; idx <= decl->Range.Last; idx++) {
  244.                         ctx->load_input(ctx, idx, decl);
  245.                 }
  246.         }
  247.         break;
  248.  
  249.         case TGSI_FILE_SYSTEM_VALUE:
  250.         {
  251.                 unsigned idx;
  252.                 for (idx = decl->Range.First; idx <= decl->Range.Last; idx++) {
  253.                         ctx->load_system_value(ctx, idx, decl);
  254.                 }
  255.         }
  256.         break;
  257.  
  258.         case TGSI_FILE_OUTPUT:
  259.         {
  260.                 unsigned idx;
  261.                 for (idx = decl->Range.First; idx <= decl->Range.Last; idx++) {
  262.                         unsigned chan;
  263.                         assert(idx < RADEON_LLVM_MAX_OUTPUTS);
  264.                         for (chan = 0; chan < TGSI_NUM_CHANNELS; chan++) {
  265.                                 ctx->soa.outputs[idx][chan] = lp_build_alloca(&ctx->gallivm,
  266.                                         ctx->soa.bld_base.base.elem_type, "");
  267.                         }
  268.                 }
  269.  
  270.                 ctx->output_reg_count = MAX2(ctx->output_reg_count,
  271.                                                          decl->Range.Last + 1);
  272.                 break;
  273.         }
  274.  
  275.         default:
  276.                 break;
  277.         }
  278. }
  279.  
  280. static void
  281. emit_store(
  282.         struct lp_build_tgsi_context * bld_base,
  283.         const struct tgsi_full_instruction * inst,
  284.         const struct tgsi_opcode_info * info,
  285.         LLVMValueRef dst[4])
  286. {
  287.         struct lp_build_tgsi_soa_context *bld = lp_soa_context(bld_base);
  288.         struct gallivm_state *gallivm = bld->bld_base.base.gallivm;
  289.         struct lp_build_context base = bld->bld_base.base;
  290.         const struct tgsi_full_dst_register *reg = &inst->Dst[0];
  291.         LLVMBuilderRef builder = bld->bld_base.base.gallivm->builder;
  292.         LLVMValueRef temp_ptr;
  293.         unsigned chan, chan_index;
  294.         boolean is_vec_store = FALSE;
  295.  
  296.         if (dst[0]) {
  297.                 LLVMTypeKind k = LLVMGetTypeKind(LLVMTypeOf(dst[0]));
  298.                 is_vec_store = (k == LLVMVectorTypeKind);
  299.         }
  300.  
  301.         if (is_vec_store) {
  302.                 LLVMValueRef values[4] = {};
  303.                 TGSI_FOR_EACH_DST0_ENABLED_CHANNEL(inst, chan) {
  304.                         LLVMValueRef index = lp_build_const_int32(gallivm, chan);
  305.                         values[chan]  = LLVMBuildExtractElement(gallivm->builder,
  306.                                                         dst[0], index, "");
  307.                 }
  308.                 bld_base->emit_store(bld_base, inst, info, values);
  309.                 return;
  310.         }
  311.  
  312.         TGSI_FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
  313.                 LLVMValueRef value = dst[chan_index];
  314.  
  315.                 if (inst->Instruction.Saturate != TGSI_SAT_NONE) {
  316.                         struct lp_build_emit_data clamp_emit_data;
  317.  
  318.                         memset(&clamp_emit_data, 0, sizeof(clamp_emit_data));
  319.                         clamp_emit_data.arg_count = 3;
  320.                         clamp_emit_data.args[0] = value;
  321.                         clamp_emit_data.args[2] = base.one;
  322.  
  323.                         switch(inst->Instruction.Saturate) {
  324.                         case TGSI_SAT_ZERO_ONE:
  325.                                 clamp_emit_data.args[1] = base.zero;
  326.                                 break;
  327.                         case TGSI_SAT_MINUS_PLUS_ONE:
  328.                                 clamp_emit_data.args[1] = LLVMConstReal(
  329.                                                 base.elem_type, -1.0f);
  330.                                 break;
  331.                         default:
  332.                                 assert(0);
  333.                         }
  334.                         value = lp_build_emit_llvm(bld_base, TGSI_OPCODE_CLAMP,
  335.                                                 &clamp_emit_data);
  336.                 }
  337.  
  338.                 if (reg->Register.File == TGSI_FILE_ADDRESS) {
  339.                         temp_ptr = bld->addr[reg->Register.Index][chan_index];
  340.                         LLVMBuildStore(builder, value, temp_ptr);
  341.                         continue;
  342.                 }
  343.        
  344.                 value = bitcast(bld_base, TGSI_TYPE_FLOAT, value);
  345.  
  346.                 if (reg->Register.Indirect) {
  347.                         struct tgsi_declaration_range range = get_array_range(bld_base,
  348.                                 reg->Register.File, &reg->Indirect);
  349.  
  350.                         unsigned i, size = range.Last - range.First + 1;
  351.                         LLVMValueRef array = LLVMBuildInsertElement(builder,
  352.                                 emit_array_fetch(bld_base, reg->Register.File, TGSI_TYPE_FLOAT, range, chan_index),
  353.                                 value,  emit_array_index(bld, &reg->Indirect, reg->Register.Index - range.First), "");
  354.  
  355.                         for (i = 0; i < size; ++i) {
  356.                                 switch(reg->Register.File) {
  357.                                 case TGSI_FILE_OUTPUT:
  358.                                         temp_ptr = bld->outputs[i + range.First][chan_index];
  359.                                         break;
  360.  
  361.                                 case TGSI_FILE_TEMPORARY:
  362.                                         temp_ptr = lp_get_temp_ptr_soa(bld, i + range.First, chan_index);
  363.                                         break;
  364.  
  365.                                 default:
  366.                                         return;
  367.                                 }
  368.                                 value = LLVMBuildExtractElement(builder, array,
  369.                                         lp_build_const_int32(gallivm, i), "");
  370.                                 LLVMBuildStore(builder, value, temp_ptr);
  371.                         }
  372.  
  373.                 } else {
  374.                         switch(reg->Register.File) {
  375.                         case TGSI_FILE_OUTPUT:
  376.                                 temp_ptr = bld->outputs[reg->Register.Index][chan_index];
  377.                                 break;
  378.  
  379.                         case TGSI_FILE_TEMPORARY:
  380.                                 temp_ptr = lp_get_temp_ptr_soa(bld, reg->Register.Index, chan_index);
  381.                                 break;
  382.  
  383.                         default:
  384.                                 return;
  385.                         }
  386.                         LLVMBuildStore(builder, value, temp_ptr);
  387.                 }
  388.         }
  389. }
  390.  
  391. static void bgnloop_emit(
  392.         const struct lp_build_tgsi_action * action,
  393.         struct lp_build_tgsi_context * bld_base,
  394.         struct lp_build_emit_data * emit_data)
  395. {
  396.         struct radeon_llvm_context * ctx = radeon_llvm_context(bld_base);
  397.         struct gallivm_state * gallivm = bld_base->base.gallivm;
  398.         LLVMBasicBlockRef loop_block;
  399.         LLVMBasicBlockRef endloop_block;
  400.         endloop_block = LLVMAppendBasicBlockInContext(gallivm->context,
  401.                                                 ctx->main_fn, "ENDLOOP");
  402.         loop_block = LLVMInsertBasicBlockInContext(gallivm->context,
  403.                                                 endloop_block, "LOOP");
  404.         LLVMBuildBr(gallivm->builder, loop_block);
  405.         LLVMPositionBuilderAtEnd(gallivm->builder, loop_block);
  406.         ctx->loop_depth++;
  407.         ctx->loop[ctx->loop_depth - 1].loop_block = loop_block;
  408.         ctx->loop[ctx->loop_depth - 1].endloop_block = endloop_block;
  409. }
  410.  
  411. static void brk_emit(
  412.         const struct lp_build_tgsi_action * action,
  413.         struct lp_build_tgsi_context * bld_base,
  414.         struct lp_build_emit_data * emit_data)
  415. {
  416.         struct radeon_llvm_context * ctx = radeon_llvm_context(bld_base);
  417.         struct gallivm_state * gallivm = bld_base->base.gallivm;
  418.         struct radeon_llvm_loop * current_loop = get_current_loop(ctx);
  419.  
  420.         LLVMBuildBr(gallivm->builder, current_loop->endloop_block);
  421. }
  422.  
  423. static void cont_emit(
  424.         const struct lp_build_tgsi_action * action,
  425.         struct lp_build_tgsi_context * bld_base,
  426.         struct lp_build_emit_data * emit_data)
  427. {
  428.         struct radeon_llvm_context * ctx = radeon_llvm_context(bld_base);
  429.         struct gallivm_state * gallivm = bld_base->base.gallivm;
  430.         struct radeon_llvm_loop * current_loop = get_current_loop(ctx);
  431.  
  432.         LLVMBuildBr(gallivm->builder, current_loop->loop_block);
  433. }
  434.  
  435. static void else_emit(
  436.         const struct lp_build_tgsi_action * action,
  437.         struct lp_build_tgsi_context * bld_base,
  438.         struct lp_build_emit_data * emit_data)
  439. {
  440.         struct radeon_llvm_context * ctx = radeon_llvm_context(bld_base);
  441.         struct gallivm_state * gallivm = bld_base->base.gallivm;
  442.         struct radeon_llvm_branch * current_branch = get_current_branch(ctx);
  443.         LLVMBasicBlockRef current_block = LLVMGetInsertBlock(gallivm->builder);
  444.  
  445.         /* We need to add a terminator to the current block if the previous
  446.          * instruction was an ENDIF.Example:
  447.          * IF
  448.          *   [code]
  449.          *   IF
  450.          *     [code]
  451.          *   ELSE
  452.          *    [code]
  453.          *   ENDIF <--
  454.          * ELSE<--
  455.          *   [code]
  456.          * ENDIF
  457.          */
  458.  
  459.         if (current_block != current_branch->if_block) {
  460.                 LLVMBuildBr(gallivm->builder, current_branch->endif_block);
  461.         }
  462.         if (!LLVMGetBasicBlockTerminator(current_branch->if_block)) {
  463.                 LLVMBuildBr(gallivm->builder, current_branch->endif_block);
  464.         }
  465.         current_branch->has_else = 1;
  466.         LLVMPositionBuilderAtEnd(gallivm->builder, current_branch->else_block);
  467. }
  468.  
  469. static void endif_emit(
  470.         const struct lp_build_tgsi_action * action,
  471.         struct lp_build_tgsi_context * bld_base,
  472.         struct lp_build_emit_data * emit_data)
  473. {
  474.         struct radeon_llvm_context * ctx = radeon_llvm_context(bld_base);
  475.         struct gallivm_state * gallivm = bld_base->base.gallivm;
  476.         struct radeon_llvm_branch * current_branch = get_current_branch(ctx);
  477.         LLVMBasicBlockRef current_block = LLVMGetInsertBlock(gallivm->builder);
  478.  
  479.         /* If we have consecutive ENDIF instructions, then the first ENDIF
  480.          * will not have a terminator, so we need to add one. */
  481.         if (current_block != current_branch->if_block
  482.                         && current_block != current_branch->else_block
  483.                         && !LLVMGetBasicBlockTerminator(current_block)) {
  484.  
  485.                  LLVMBuildBr(gallivm->builder, current_branch->endif_block);
  486.         }
  487.         if (!LLVMGetBasicBlockTerminator(current_branch->else_block)) {
  488.                 LLVMPositionBuilderAtEnd(gallivm->builder, current_branch->else_block);
  489.                 LLVMBuildBr(gallivm->builder, current_branch->endif_block);
  490.         }
  491.  
  492.         if (!LLVMGetBasicBlockTerminator(current_branch->if_block)) {
  493.                 LLVMPositionBuilderAtEnd(gallivm->builder, current_branch->if_block);
  494.                 LLVMBuildBr(gallivm->builder, current_branch->endif_block);
  495.         }
  496.  
  497.         LLVMPositionBuilderAtEnd(gallivm->builder, current_branch->endif_block);
  498.         ctx->branch_depth--;
  499. }
  500.  
  501. static void endloop_emit(
  502.         const struct lp_build_tgsi_action * action,
  503.         struct lp_build_tgsi_context * bld_base,
  504.         struct lp_build_emit_data * emit_data)
  505. {
  506.         struct radeon_llvm_context * ctx = radeon_llvm_context(bld_base);
  507.         struct gallivm_state * gallivm = bld_base->base.gallivm;
  508.         struct radeon_llvm_loop * current_loop = get_current_loop(ctx);
  509.  
  510.         if (!LLVMGetBasicBlockTerminator(LLVMGetInsertBlock(gallivm->builder))) {
  511.                  LLVMBuildBr(gallivm->builder, current_loop->loop_block);
  512.         }
  513.  
  514.         LLVMPositionBuilderAtEnd(gallivm->builder, current_loop->endloop_block);
  515.         ctx->loop_depth--;
  516. }
  517.  
  518. static void if_cond_emit(
  519.         const struct lp_build_tgsi_action * action,
  520.         struct lp_build_tgsi_context * bld_base,
  521.         struct lp_build_emit_data * emit_data,
  522.         LLVMValueRef cond)
  523. {
  524.         struct radeon_llvm_context * ctx = radeon_llvm_context(bld_base);
  525.         struct gallivm_state * gallivm = bld_base->base.gallivm;
  526.         LLVMBasicBlockRef if_block, else_block, endif_block;
  527.  
  528.         endif_block = LLVMAppendBasicBlockInContext(gallivm->context,
  529.                                                 ctx->main_fn, "ENDIF");
  530.         if_block = LLVMInsertBasicBlockInContext(gallivm->context,
  531.                                                 endif_block, "IF");
  532.         else_block = LLVMInsertBasicBlockInContext(gallivm->context,
  533.                                                 endif_block, "ELSE");
  534.         LLVMBuildCondBr(gallivm->builder, cond, if_block, else_block);
  535.         LLVMPositionBuilderAtEnd(gallivm->builder, if_block);
  536.  
  537.         ctx->branch_depth++;
  538.         ctx->branch[ctx->branch_depth - 1].endif_block = endif_block;
  539.         ctx->branch[ctx->branch_depth - 1].if_block = if_block;
  540.         ctx->branch[ctx->branch_depth - 1].else_block = else_block;
  541.         ctx->branch[ctx->branch_depth - 1].has_else = 0;
  542. }
  543.  
  544. static void if_emit(
  545.         const struct lp_build_tgsi_action * action,
  546.         struct lp_build_tgsi_context * bld_base,
  547.         struct lp_build_emit_data * emit_data)
  548. {
  549.         struct gallivm_state * gallivm = bld_base->base.gallivm;
  550.         LLVMValueRef cond;
  551.  
  552.         cond = LLVMBuildFCmp(gallivm->builder, LLVMRealUNE,
  553.                         emit_data->args[0],
  554.                         bld_base->base.zero, "");
  555.  
  556.         if_cond_emit(action, bld_base, emit_data, cond);
  557. }
  558.  
  559. static void uif_emit(
  560.         const struct lp_build_tgsi_action * action,
  561.         struct lp_build_tgsi_context * bld_base,
  562.         struct lp_build_emit_data * emit_data)
  563. {
  564.         struct gallivm_state * gallivm = bld_base->base.gallivm;
  565.         LLVMValueRef cond;
  566.  
  567.         cond = LLVMBuildICmp(gallivm->builder, LLVMIntNE,
  568.                 bitcast(bld_base, TGSI_TYPE_UNSIGNED, emit_data->args[0]),
  569.                         bld_base->int_bld.zero, "");
  570.  
  571.         if_cond_emit(action, bld_base, emit_data, cond);
  572. }
  573.  
  574. static void kil_emit(
  575.         const struct lp_build_tgsi_action * action,
  576.         struct lp_build_tgsi_context * bld_base,
  577.         struct lp_build_emit_data * emit_data)
  578. {
  579.         unsigned i;
  580.         for (i = 0; i < emit_data->arg_count; i++) {
  581.                 emit_data->output[i] = lp_build_intrinsic_unary(
  582.                         bld_base->base.gallivm->builder,
  583.                         action->intr_name,
  584.                         emit_data->dst_type, emit_data->args[i]);
  585.         }
  586. }
  587.  
  588. void radeon_llvm_emit_prepare_cube_coords(
  589.                 struct lp_build_tgsi_context * bld_base,
  590.                 struct lp_build_emit_data * emit_data,
  591.                 LLVMValueRef *coords_arg)
  592. {
  593.  
  594.         unsigned target = emit_data->inst->Texture.Texture;
  595.         unsigned opcode = emit_data->inst->Instruction.Opcode;
  596.         struct gallivm_state * gallivm = bld_base->base.gallivm;
  597.         LLVMBuilderRef builder = gallivm->builder;
  598.         LLVMTypeRef type = bld_base->base.elem_type;
  599.         LLVMValueRef coords[4];
  600.         LLVMValueRef mad_args[3];
  601.         LLVMValueRef idx;
  602.         struct LLVMOpaqueValue *cube_vec;
  603.         LLVMValueRef v;
  604.         unsigned i;
  605.  
  606.         cube_vec = lp_build_gather_values(bld_base->base.gallivm, coords_arg, 4);
  607.         v = build_intrinsic(builder, "llvm.AMDGPU.cube", LLVMVectorType(type, 4),
  608.                             &cube_vec, 1, LLVMReadNoneAttribute);
  609.  
  610.         for (i = 0; i < 4; ++i) {
  611.                 idx = lp_build_const_int32(gallivm, i);
  612.                 coords[i] = LLVMBuildExtractElement(builder, v, idx, "");
  613.         }
  614.  
  615.         coords[2] = build_intrinsic(builder, "fabs",
  616.                         type, &coords[2], 1, LLVMReadNoneAttribute);
  617.         coords[2] = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_RCP, coords[2]);
  618.  
  619.         mad_args[1] = coords[2];
  620.         mad_args[2] = LLVMConstReal(type, 1.5);
  621.  
  622.         mad_args[0] = coords[0];
  623.         coords[0] = lp_build_emit_llvm_ternary(bld_base, TGSI_OPCODE_MAD,
  624.                         mad_args[0], mad_args[1], mad_args[2]);
  625.  
  626.         mad_args[0] = coords[1];
  627.         coords[1] = lp_build_emit_llvm_ternary(bld_base, TGSI_OPCODE_MAD,
  628.                         mad_args[0], mad_args[1], mad_args[2]);
  629.  
  630.         /* apply xyz = yxw swizzle to cooords */
  631.         coords[2] = coords[3];
  632.         coords[3] = coords[1];
  633.         coords[1] = coords[0];
  634.         coords[0] = coords[3];
  635.  
  636.         /* all cases except simple cube map sampling require special handling
  637.          * for coord vector */
  638.         if (target != TGSI_TEXTURE_CUBE ||
  639.                 opcode != TGSI_OPCODE_TEX) {
  640.  
  641.                 /* for cube arrays coord.z = coord.w(array_index) * 8 + face */
  642.                 if (target == TGSI_TEXTURE_CUBE_ARRAY ||
  643.                         target == TGSI_TEXTURE_SHADOWCUBE_ARRAY) {
  644.  
  645.                         /* coords_arg.w component - array_index for cube arrays or
  646.                          * compare value for SHADOWCUBE */
  647.                         coords[2] = lp_build_emit_llvm_ternary(bld_base, TGSI_OPCODE_MAD,
  648.                                         coords_arg[3], lp_build_const_float(gallivm, 8.0), coords[2]);
  649.                 }
  650.  
  651.                 /* for instructions that need additional src (compare/lod/bias),
  652.                  * put it in coord.w */
  653.                 if (opcode == TGSI_OPCODE_TEX2 ||
  654.                         opcode == TGSI_OPCODE_TXB2 ||
  655.                         opcode == TGSI_OPCODE_TXL2) {
  656.                         coords[3] = coords_arg[4];
  657.                 } else if (opcode == TGSI_OPCODE_TXB ||
  658.                         opcode == TGSI_OPCODE_TXL) {
  659.                         coords[3] = coords_arg[3];
  660.                 }
  661.         }
  662.  
  663.         memcpy(coords_arg, coords, sizeof(coords));
  664. }
  665.  
  666. static void txd_fetch_args(
  667.         struct lp_build_tgsi_context * bld_base,
  668.         struct lp_build_emit_data * emit_data)
  669. {
  670.         const struct tgsi_full_instruction * inst = emit_data->inst;
  671.  
  672.         LLVMValueRef coords[4];
  673.         unsigned chan, src;
  674.         for (src = 0; src < 3; src++) {
  675.                 for (chan = 0; chan < 4; chan++)
  676.                         coords[chan] = lp_build_emit_fetch(bld_base, inst, src, chan);
  677.  
  678.                 emit_data->args[src] = lp_build_gather_values(bld_base->base.gallivm,
  679.                                 coords, 4);
  680.         }
  681.         emit_data->arg_count = 3;
  682.         emit_data->dst_type = LLVMVectorType(bld_base->base.elem_type, 4);
  683. }
  684.  
  685.  
  686. static void txp_fetch_args(
  687.         struct lp_build_tgsi_context * bld_base,
  688.         struct lp_build_emit_data * emit_data)
  689. {
  690.         const struct tgsi_full_instruction * inst = emit_data->inst;
  691.         LLVMValueRef src_w;
  692.         unsigned chan;
  693.         LLVMValueRef coords[4];
  694.  
  695.         emit_data->dst_type = LLVMVectorType(bld_base->base.elem_type, 4);
  696.         src_w = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_W);
  697.  
  698.         for (chan = 0; chan < 3; chan++ ) {
  699.                 LLVMValueRef arg = lp_build_emit_fetch(bld_base,
  700.                                                 emit_data->inst, 0, chan);
  701.                 coords[chan] = lp_build_emit_llvm_binary(bld_base,
  702.                                         TGSI_OPCODE_DIV, arg, src_w);
  703.         }
  704.         coords[3] = bld_base->base.one;
  705.  
  706.         if ((inst->Texture.Texture == TGSI_TEXTURE_CUBE ||
  707.              inst->Texture.Texture == TGSI_TEXTURE_CUBE_ARRAY ||
  708.              inst->Texture.Texture == TGSI_TEXTURE_SHADOWCUBE ||
  709.              inst->Texture.Texture == TGSI_TEXTURE_SHADOWCUBE_ARRAY) &&
  710.             inst->Instruction.Opcode != TGSI_OPCODE_TXQ &&
  711.             inst->Instruction.Opcode != TGSI_OPCODE_TXQ_LZ) {
  712.                 radeon_llvm_emit_prepare_cube_coords(bld_base, emit_data, coords);
  713.         }
  714.  
  715.         emit_data->args[0] = lp_build_gather_values(bld_base->base.gallivm,
  716.                                                 coords, 4);
  717.         emit_data->arg_count = 1;
  718. }
  719.  
  720. static void tex_fetch_args(
  721.         struct lp_build_tgsi_context * bld_base,
  722.         struct lp_build_emit_data * emit_data)
  723. {
  724.         /* XXX: lp_build_swizzle_aos() was failing with wrong arg types,
  725.          * when we used CHAN_ALL.  We should be able to get this to work,
  726.          * but for now we will swizzle it ourselves
  727.         emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst,
  728.                                                  0, CHAN_ALL);
  729.  
  730.         */
  731.  
  732.         const struct tgsi_full_instruction * inst = emit_data->inst;
  733.  
  734.         LLVMValueRef coords[5];
  735.         unsigned chan;
  736.         for (chan = 0; chan < 4; chan++) {
  737.                 coords[chan] = lp_build_emit_fetch(bld_base, inst, 0, chan);
  738.         }
  739.  
  740.         if (inst->Instruction.Opcode == TGSI_OPCODE_TEX2 ||
  741.                 inst->Instruction.Opcode == TGSI_OPCODE_TXB2 ||
  742.                 inst->Instruction.Opcode == TGSI_OPCODE_TXL2) {
  743.                 /* These instructions have additional operand that should be packed
  744.                  * into the cube coord vector by radeon_llvm_emit_prepare_cube_coords.
  745.                  * That operand should be passed as a float value in the args array
  746.                  * right after the coord vector. After packing it's not used anymore,
  747.                  * that's why arg_count is not increased */
  748.                 coords[4] = lp_build_emit_fetch(bld_base, inst, 1, 0);
  749.         }
  750.  
  751.         if ((inst->Texture.Texture == TGSI_TEXTURE_CUBE ||
  752.              inst->Texture.Texture == TGSI_TEXTURE_CUBE_ARRAY ||
  753.              inst->Texture.Texture == TGSI_TEXTURE_SHADOWCUBE ||
  754.              inst->Texture.Texture == TGSI_TEXTURE_SHADOWCUBE_ARRAY) &&
  755.             inst->Instruction.Opcode != TGSI_OPCODE_TXQ &&
  756.             inst->Instruction.Opcode != TGSI_OPCODE_TXQ_LZ) {
  757.                 radeon_llvm_emit_prepare_cube_coords(bld_base, emit_data, coords);
  758.         }
  759.  
  760.         emit_data->arg_count = 1;
  761.         emit_data->args[0] = lp_build_gather_values(bld_base->base.gallivm,
  762.                                                 coords, 4);
  763.         emit_data->dst_type = LLVMVectorType(bld_base->base.elem_type, 4);
  764. }
  765.  
  766. static void txf_fetch_args(
  767.         struct lp_build_tgsi_context * bld_base,
  768.         struct lp_build_emit_data * emit_data)
  769. {
  770.         const struct tgsi_full_instruction * inst = emit_data->inst;
  771.         struct lp_build_tgsi_soa_context *bld = lp_soa_context(bld_base);
  772.         const struct tgsi_texture_offset * off = inst->TexOffsets;
  773.         LLVMTypeRef offset_type = bld_base->int_bld.elem_type;
  774.  
  775.         /* fetch tex coords */
  776.         tex_fetch_args(bld_base, emit_data);
  777.  
  778.         /* fetch tex offsets */
  779.         if (inst->Texture.NumOffsets) {
  780.                 assert(inst->Texture.NumOffsets == 1);
  781.  
  782.                 emit_data->args[1] = LLVMConstBitCast(
  783.                         bld->immediates[off->Index][off->SwizzleX],
  784.                         offset_type);
  785.                 emit_data->args[2] = LLVMConstBitCast(
  786.                         bld->immediates[off->Index][off->SwizzleY],
  787.                         offset_type);
  788.                 emit_data->args[3] = LLVMConstBitCast(
  789.                         bld->immediates[off->Index][off->SwizzleZ],
  790.                         offset_type);
  791.         } else {
  792.                 emit_data->args[1] = bld_base->int_bld.zero;
  793.                 emit_data->args[2] = bld_base->int_bld.zero;
  794.                 emit_data->args[3] = bld_base->int_bld.zero;
  795.         }
  796.  
  797.         emit_data->arg_count = 4;
  798. }
  799.  
  800. static void emit_icmp(
  801.                 const struct lp_build_tgsi_action * action,
  802.                 struct lp_build_tgsi_context * bld_base,
  803.                 struct lp_build_emit_data * emit_data)
  804. {
  805.         unsigned pred;
  806.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  807.         LLVMContextRef context = bld_base->base.gallivm->context;
  808.  
  809.         switch (emit_data->inst->Instruction.Opcode) {
  810.         case TGSI_OPCODE_USEQ: pred = LLVMIntEQ; break;
  811.         case TGSI_OPCODE_USNE: pred = LLVMIntNE; break;
  812.         case TGSI_OPCODE_USGE: pred = LLVMIntUGE; break;
  813.         case TGSI_OPCODE_USLT: pred = LLVMIntULT; break;
  814.         case TGSI_OPCODE_ISGE: pred = LLVMIntSGE; break;
  815.         case TGSI_OPCODE_ISLT: pred = LLVMIntSLT; break;
  816.         default:
  817.                 assert(!"unknown instruction");
  818.                 pred = 0;
  819.                 break;
  820.         }
  821.  
  822.         LLVMValueRef v = LLVMBuildICmp(builder, pred,
  823.                         emit_data->args[0], emit_data->args[1],"");
  824.  
  825.         v = LLVMBuildSExtOrBitCast(builder, v,
  826.                         LLVMInt32TypeInContext(context), "");
  827.  
  828.         emit_data->output[emit_data->chan] = v;
  829. }
  830.  
  831. static void emit_ucmp(
  832.                 const struct lp_build_tgsi_action * action,
  833.                 struct lp_build_tgsi_context * bld_base,
  834.                 struct lp_build_emit_data * emit_data)
  835. {
  836.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  837.  
  838.         LLVMValueRef v = LLVMBuildFCmp(builder, LLVMRealUGE,
  839.                         emit_data->args[0], lp_build_const_float(bld_base->base.gallivm, 0.), "");
  840.  
  841.         emit_data->output[emit_data->chan] = LLVMBuildSelect(builder, v, emit_data->args[2], emit_data->args[1], "");
  842. }
  843.  
  844. static void emit_cmp(
  845.                 const struct lp_build_tgsi_action *action,
  846.                 struct lp_build_tgsi_context * bld_base,
  847.                 struct lp_build_emit_data * emit_data)
  848. {
  849.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  850.         LLVMRealPredicate pred;
  851.         LLVMValueRef cond;
  852.  
  853.         /* XXX I'm not sure whether to do unordered or ordered comparisons,
  854.          * but llvmpipe uses unordered comparisons, so for consistency we use
  855.          * unordered.  (The authors of llvmpipe aren't sure about using
  856.          * unordered vs ordered comparisons either.
  857.          */
  858.         switch (emit_data->inst->Instruction.Opcode) {
  859.         case TGSI_OPCODE_SGE: pred = LLVMRealUGE; break;
  860.         case TGSI_OPCODE_SEQ: pred = LLVMRealUEQ; break;
  861.         case TGSI_OPCODE_SLE: pred = LLVMRealULE; break;
  862.         case TGSI_OPCODE_SLT: pred = LLVMRealULT; break;
  863.         case TGSI_OPCODE_SNE: pred = LLVMRealUNE; break;
  864.         case TGSI_OPCODE_SGT: pred = LLVMRealUGT; break;
  865.         default: assert(!"unknown instruction"); pred = 0; break;
  866.         }
  867.  
  868.         cond = LLVMBuildFCmp(builder,
  869.                 pred, emit_data->args[0], emit_data->args[1], "");
  870.  
  871.         emit_data->output[emit_data->chan] = LLVMBuildSelect(builder,
  872.                 cond, bld_base->base.one, bld_base->base.zero, "");
  873. }
  874.  
  875. static void emit_not(
  876.                 const struct lp_build_tgsi_action * action,
  877.                 struct lp_build_tgsi_context * bld_base,
  878.                 struct lp_build_emit_data * emit_data)
  879. {
  880.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  881.         LLVMValueRef v = bitcast(bld_base, TGSI_TYPE_UNSIGNED,
  882.                         emit_data->args[0]);
  883.         emit_data->output[emit_data->chan] = LLVMBuildNot(builder, v, "");
  884. }
  885.  
  886. static void emit_arl(
  887.                 const struct lp_build_tgsi_action * action,
  888.                 struct lp_build_tgsi_context * bld_base,
  889.                 struct lp_build_emit_data * emit_data)
  890. {
  891.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  892.         LLVMValueRef floor_index =  lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_FLR, emit_data->args[0]);
  893.         emit_data->output[emit_data->chan] = LLVMBuildFPToSI(builder,
  894.                         floor_index, bld_base->base.int_elem_type , "");
  895. }
  896.  
  897. static void emit_and(
  898.                 const struct lp_build_tgsi_action * action,
  899.                 struct lp_build_tgsi_context * bld_base,
  900.                 struct lp_build_emit_data * emit_data)
  901. {
  902.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  903.         emit_data->output[emit_data->chan] = LLVMBuildAnd(builder,
  904.                         emit_data->args[0], emit_data->args[1], "");
  905. }
  906.  
  907. static void emit_or(
  908.                 const struct lp_build_tgsi_action * action,
  909.                 struct lp_build_tgsi_context * bld_base,
  910.                 struct lp_build_emit_data * emit_data)
  911. {
  912.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  913.         emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
  914.                         emit_data->args[0], emit_data->args[1], "");
  915. }
  916.  
  917. static void emit_uadd(
  918.                 const struct lp_build_tgsi_action * action,
  919.                 struct lp_build_tgsi_context * bld_base,
  920.                 struct lp_build_emit_data * emit_data)
  921. {
  922.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  923.         emit_data->output[emit_data->chan] = LLVMBuildAdd(builder,
  924.                         emit_data->args[0], emit_data->args[1], "");
  925. }
  926.  
  927. static void emit_udiv(
  928.                 const struct lp_build_tgsi_action * action,
  929.                 struct lp_build_tgsi_context * bld_base,
  930.                 struct lp_build_emit_data * emit_data)
  931. {
  932.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  933.         emit_data->output[emit_data->chan] = LLVMBuildUDiv(builder,
  934.                         emit_data->args[0], emit_data->args[1], "");
  935. }
  936.  
  937. static void emit_idiv(
  938.                 const struct lp_build_tgsi_action * action,
  939.                 struct lp_build_tgsi_context * bld_base,
  940.                 struct lp_build_emit_data * emit_data)
  941. {
  942.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  943.         emit_data->output[emit_data->chan] = LLVMBuildSDiv(builder,
  944.                         emit_data->args[0], emit_data->args[1], "");
  945. }
  946.  
  947. static void emit_mod(
  948.                 const struct lp_build_tgsi_action * action,
  949.                 struct lp_build_tgsi_context * bld_base,
  950.                 struct lp_build_emit_data * emit_data)
  951. {
  952.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  953.         emit_data->output[emit_data->chan] = LLVMBuildSRem(builder,
  954.                         emit_data->args[0], emit_data->args[1], "");
  955. }
  956.  
  957. static void emit_umod(
  958.                 const struct lp_build_tgsi_action * action,
  959.                 struct lp_build_tgsi_context * bld_base,
  960.                 struct lp_build_emit_data * emit_data)
  961. {
  962.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  963.         emit_data->output[emit_data->chan] = LLVMBuildURem(builder,
  964.                         emit_data->args[0], emit_data->args[1], "");
  965. }
  966.  
  967. static void emit_shl(
  968.                 const struct lp_build_tgsi_action * action,
  969.                 struct lp_build_tgsi_context * bld_base,
  970.                 struct lp_build_emit_data * emit_data)
  971. {
  972.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  973.         emit_data->output[emit_data->chan] = LLVMBuildShl(builder,
  974.                         emit_data->args[0], emit_data->args[1], "");
  975. }
  976.  
  977. static void emit_ushr(
  978.                 const struct lp_build_tgsi_action * action,
  979.                 struct lp_build_tgsi_context * bld_base,
  980.                 struct lp_build_emit_data * emit_data)
  981. {
  982.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  983.         emit_data->output[emit_data->chan] = LLVMBuildLShr(builder,
  984.                         emit_data->args[0], emit_data->args[1], "");
  985. }
  986. static void emit_ishr(
  987.                 const struct lp_build_tgsi_action * action,
  988.                 struct lp_build_tgsi_context * bld_base,
  989.                 struct lp_build_emit_data * emit_data)
  990. {
  991.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  992.         emit_data->output[emit_data->chan] = LLVMBuildAShr(builder,
  993.                         emit_data->args[0], emit_data->args[1], "");
  994. }
  995.  
  996. static void emit_xor(
  997.                 const struct lp_build_tgsi_action * action,
  998.                 struct lp_build_tgsi_context * bld_base,
  999.                 struct lp_build_emit_data * emit_data)
  1000. {
  1001.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  1002.         emit_data->output[emit_data->chan] = LLVMBuildXor(builder,
  1003.                         emit_data->args[0], emit_data->args[1], "");
  1004. }
  1005.  
  1006. static void emit_ssg(
  1007.                 const struct lp_build_tgsi_action * action,
  1008.                 struct lp_build_tgsi_context * bld_base,
  1009.                 struct lp_build_emit_data * emit_data)
  1010. {
  1011.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  1012.  
  1013.         LLVMValueRef cmp, val;
  1014.  
  1015.         if (emit_data->inst->Instruction.Opcode == TGSI_OPCODE_ISSG) {
  1016.                 cmp = LLVMBuildICmp(builder, LLVMIntSGT, emit_data->args[0], bld_base->int_bld.zero, "");
  1017.                 val = LLVMBuildSelect(builder, cmp, bld_base->int_bld.one, emit_data->args[0], "");
  1018.                 cmp = LLVMBuildICmp(builder, LLVMIntSGE, val, bld_base->int_bld.zero, "");
  1019.                 val = LLVMBuildSelect(builder, cmp, val, LLVMConstInt(bld_base->int_bld.elem_type, -1, true), "");
  1020.         } else { // float SSG
  1021.                 cmp = LLVMBuildFCmp(builder, LLVMRealUGT, emit_data->args[0], bld_base->base.zero, "");
  1022.                 val = LLVMBuildSelect(builder, cmp, bld_base->base.one, emit_data->args[0], "");
  1023.                 cmp = LLVMBuildFCmp(builder, LLVMRealUGE, val, bld_base->base.zero, "");
  1024.                 val = LLVMBuildSelect(builder, cmp, val, LLVMConstReal(bld_base->base.elem_type, -1), "");
  1025.         }
  1026.  
  1027.         emit_data->output[emit_data->chan] = val;
  1028. }
  1029.  
  1030. static void emit_ineg(
  1031.                 const struct lp_build_tgsi_action * action,
  1032.                 struct lp_build_tgsi_context * bld_base,
  1033.                 struct lp_build_emit_data * emit_data)
  1034. {
  1035.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  1036.         emit_data->output[emit_data->chan] = LLVMBuildNeg(builder,
  1037.                         emit_data->args[0], "");
  1038. }
  1039.  
  1040. static void emit_f2i(
  1041.                 const struct lp_build_tgsi_action * action,
  1042.                 struct lp_build_tgsi_context * bld_base,
  1043.                 struct lp_build_emit_data * emit_data)
  1044. {
  1045.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  1046.         emit_data->output[emit_data->chan] = LLVMBuildFPToSI(builder,
  1047.                         emit_data->args[0], bld_base->int_bld.elem_type, "");
  1048. }
  1049.  
  1050. static void emit_f2u(
  1051.                 const struct lp_build_tgsi_action * action,
  1052.                 struct lp_build_tgsi_context * bld_base,
  1053.                 struct lp_build_emit_data * emit_data)
  1054. {
  1055.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  1056.         emit_data->output[emit_data->chan] = LLVMBuildFPToUI(builder,
  1057.                         emit_data->args[0], bld_base->uint_bld.elem_type, "");
  1058. }
  1059.  
  1060. static void emit_i2f(
  1061.                 const struct lp_build_tgsi_action * action,
  1062.                 struct lp_build_tgsi_context * bld_base,
  1063.                 struct lp_build_emit_data * emit_data)
  1064. {
  1065.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  1066.         emit_data->output[emit_data->chan] = LLVMBuildSIToFP(builder,
  1067.                         emit_data->args[0], bld_base->base.elem_type, "");
  1068. }
  1069.  
  1070. static void emit_u2f(
  1071.                 const struct lp_build_tgsi_action * action,
  1072.                 struct lp_build_tgsi_context * bld_base,
  1073.                 struct lp_build_emit_data * emit_data)
  1074. {
  1075.         LLVMBuilderRef builder = bld_base->base.gallivm->builder;
  1076.         emit_data->output[emit_data->chan] = LLVMBuildUIToFP(builder,
  1077.                         emit_data->args[0], bld_base->base.elem_type, "");
  1078. }
  1079.  
  1080. static void emit_immediate(struct lp_build_tgsi_context * bld_base,
  1081.                 const struct tgsi_full_immediate *imm)
  1082. {
  1083.         unsigned i;
  1084.         struct radeon_llvm_context * ctx = radeon_llvm_context(bld_base);
  1085.  
  1086.         for (i = 0; i < 4; ++i) {
  1087.                 ctx->soa.immediates[ctx->soa.num_immediates][i] =
  1088.                                 LLVMConstInt(bld_base->uint_bld.elem_type, imm->u[i].Uint, false   );
  1089.         }
  1090.  
  1091.         ctx->soa.num_immediates++;
  1092. }
  1093.  
  1094. LLVMValueRef
  1095. build_intrinsic(LLVMBuilderRef builder,
  1096.                    const char *name,
  1097.                    LLVMTypeRef ret_type,
  1098.                    LLVMValueRef *args,
  1099.                    unsigned num_args,
  1100.                    LLVMAttribute attr)
  1101. {
  1102.    LLVMModuleRef module = LLVMGetGlobalParent(LLVMGetBasicBlockParent(LLVMGetInsertBlock(builder)));
  1103.    LLVMValueRef function;
  1104.  
  1105.    function = LLVMGetNamedFunction(module, name);
  1106.    if(!function) {
  1107.       LLVMTypeRef arg_types[LP_MAX_FUNC_ARGS];
  1108.       unsigned i;
  1109.  
  1110.       assert(num_args <= LP_MAX_FUNC_ARGS);
  1111.  
  1112.       for(i = 0; i < num_args; ++i) {
  1113.          assert(args[i]);
  1114.          arg_types[i] = LLVMTypeOf(args[i]);
  1115.       }
  1116.  
  1117.       function = lp_declare_intrinsic(module, name, ret_type, arg_types, num_args);
  1118.  
  1119.       if (attr)
  1120.           LLVMAddFunctionAttr(function, attr);
  1121.    }
  1122.  
  1123.    return LLVMBuildCall(builder, function, args, num_args, "");
  1124. }
  1125.  
  1126. static void build_tgsi_intrinsic(
  1127.  const struct lp_build_tgsi_action * action,
  1128.  struct lp_build_tgsi_context * bld_base,
  1129.  struct lp_build_emit_data * emit_data,
  1130.  LLVMAttribute attr)
  1131. {
  1132.    struct lp_build_context * base = &bld_base->base;
  1133.    emit_data->output[emit_data->chan] = build_intrinsic(
  1134.                base->gallivm->builder, action->intr_name,
  1135.                emit_data->dst_type, emit_data->args,
  1136.                emit_data->arg_count, attr);
  1137. }
  1138. void
  1139. build_tgsi_intrinsic_nomem(
  1140.  const struct lp_build_tgsi_action * action,
  1141.  struct lp_build_tgsi_context * bld_base,
  1142.  struct lp_build_emit_data * emit_data)
  1143. {
  1144.         build_tgsi_intrinsic(action, bld_base, emit_data, LLVMReadNoneAttribute);
  1145. }
  1146.  
  1147. static void build_tgsi_intrinsic_readonly(
  1148.  const struct lp_build_tgsi_action * action,
  1149.  struct lp_build_tgsi_context * bld_base,
  1150.  struct lp_build_emit_data * emit_data)
  1151. {
  1152.         build_tgsi_intrinsic(action, bld_base, emit_data, LLVMReadOnlyAttribute);
  1153. }
  1154.  
  1155. void radeon_llvm_context_init(struct radeon_llvm_context * ctx)
  1156. {
  1157.         struct lp_type type;
  1158.  
  1159.         /* Initialize the gallivm object:
  1160.          * We are only using the module, context, and builder fields of this struct.
  1161.          * This should be enough for us to be able to pass our gallivm struct to the
  1162.          * helper functions in the gallivm module.
  1163.          */
  1164.         memset(&ctx->gallivm, 0, sizeof (ctx->gallivm));
  1165.         memset(&ctx->soa, 0, sizeof(ctx->soa));
  1166.         ctx->gallivm.context = LLVMContextCreate();
  1167.         ctx->gallivm.module = LLVMModuleCreateWithNameInContext("tgsi",
  1168.                                                 ctx->gallivm.context);
  1169.         ctx->gallivm.builder = LLVMCreateBuilderInContext(ctx->gallivm.context);
  1170.  
  1171.         ctx->store_output_intr = "llvm.AMDGPU.store.output.";
  1172.         ctx->swizzle_intr = "llvm.AMDGPU.swizzle";
  1173.         struct lp_build_tgsi_context * bld_base = &ctx->soa.bld_base;
  1174.  
  1175.         /* XXX: We need to revisit this.I think the correct way to do this is
  1176.          * to use length = 4 here and use the elem_bld for everything. */
  1177.         type.floating = TRUE;
  1178.         type.fixed = FALSE;
  1179.         type.sign = TRUE;
  1180.         type.norm = FALSE;
  1181.         type.width = 32;
  1182.         type.length = 1;
  1183.  
  1184.         lp_build_context_init(&bld_base->base, &ctx->gallivm, type);
  1185.         lp_build_context_init(&ctx->soa.bld_base.uint_bld, &ctx->gallivm, lp_uint_type(type));
  1186.         lp_build_context_init(&ctx->soa.bld_base.int_bld, &ctx->gallivm, lp_int_type(type));
  1187.  
  1188.         bld_base->soa = 1;
  1189.         bld_base->emit_store = emit_store;
  1190.         bld_base->emit_swizzle = emit_swizzle;
  1191.         bld_base->emit_declaration = emit_declaration;
  1192.         bld_base->emit_immediate = emit_immediate;
  1193.  
  1194.         bld_base->emit_fetch_funcs[TGSI_FILE_IMMEDIATE] = emit_fetch;
  1195.         bld_base->emit_fetch_funcs[TGSI_FILE_INPUT] = emit_fetch;
  1196.         bld_base->emit_fetch_funcs[TGSI_FILE_TEMPORARY] = emit_fetch;
  1197.         bld_base->emit_fetch_funcs[TGSI_FILE_OUTPUT] = emit_fetch;
  1198.         bld_base->emit_fetch_funcs[TGSI_FILE_SYSTEM_VALUE] = fetch_system_value;
  1199.  
  1200.         /* Allocate outputs */
  1201.         ctx->soa.outputs = ctx->outputs;
  1202.  
  1203.         ctx->num_arrays = 0;
  1204.  
  1205.         /* XXX: Is there a better way to initialize all this ? */
  1206.  
  1207.         lp_set_default_actions(bld_base);
  1208.  
  1209.         bld_base->op_actions[TGSI_OPCODE_ABS].emit = build_tgsi_intrinsic_readonly;
  1210.         bld_base->op_actions[TGSI_OPCODE_ABS].intr_name = "fabs";
  1211.         bld_base->op_actions[TGSI_OPCODE_ARL].emit = emit_arl;
  1212.         bld_base->op_actions[TGSI_OPCODE_AND].emit = emit_and;
  1213.         bld_base->op_actions[TGSI_OPCODE_BGNLOOP].emit = bgnloop_emit;
  1214.         bld_base->op_actions[TGSI_OPCODE_BRK].emit = brk_emit;
  1215.         bld_base->op_actions[TGSI_OPCODE_CEIL].emit = build_tgsi_intrinsic_readonly;
  1216.         bld_base->op_actions[TGSI_OPCODE_CEIL].intr_name = "ceil";
  1217.         bld_base->op_actions[TGSI_OPCODE_CLAMP].emit = build_tgsi_intrinsic_nomem;
  1218.         bld_base->op_actions[TGSI_OPCODE_CLAMP].intr_name = "llvm.AMDIL.clamp.";
  1219.         bld_base->op_actions[TGSI_OPCODE_CMP].emit = build_tgsi_intrinsic_nomem;
  1220.         bld_base->op_actions[TGSI_OPCODE_CMP].intr_name = "llvm.AMDGPU.cndlt";
  1221.         bld_base->op_actions[TGSI_OPCODE_CONT].emit = cont_emit;
  1222.         bld_base->op_actions[TGSI_OPCODE_COS].emit = build_tgsi_intrinsic_readonly;
  1223.         bld_base->op_actions[TGSI_OPCODE_COS].intr_name = "llvm.cos.f32";
  1224.         bld_base->op_actions[TGSI_OPCODE_DDX].intr_name = "llvm.AMDGPU.ddx";
  1225.         bld_base->op_actions[TGSI_OPCODE_DDX].fetch_args = tex_fetch_args;
  1226.         bld_base->op_actions[TGSI_OPCODE_DDY].intr_name = "llvm.AMDGPU.ddy";
  1227.         bld_base->op_actions[TGSI_OPCODE_DDY].fetch_args = tex_fetch_args;
  1228.         bld_base->op_actions[TGSI_OPCODE_ELSE].emit = else_emit;
  1229.         bld_base->op_actions[TGSI_OPCODE_ENDIF].emit = endif_emit;
  1230.         bld_base->op_actions[TGSI_OPCODE_ENDLOOP].emit = endloop_emit;
  1231.         bld_base->op_actions[TGSI_OPCODE_EX2].emit = build_tgsi_intrinsic_nomem;
  1232.         bld_base->op_actions[TGSI_OPCODE_EX2].intr_name = "llvm.AMDIL.exp.";
  1233.         bld_base->op_actions[TGSI_OPCODE_FLR].emit = build_tgsi_intrinsic_readonly;
  1234.         bld_base->op_actions[TGSI_OPCODE_FLR].intr_name = "floor";
  1235.         bld_base->op_actions[TGSI_OPCODE_FRC].emit = build_tgsi_intrinsic_nomem;
  1236.         bld_base->op_actions[TGSI_OPCODE_FRC].intr_name = "llvm.AMDIL.fraction.";
  1237.         bld_base->op_actions[TGSI_OPCODE_F2I].emit = emit_f2i;
  1238.         bld_base->op_actions[TGSI_OPCODE_F2U].emit = emit_f2u;
  1239.         bld_base->op_actions[TGSI_OPCODE_IABS].emit = build_tgsi_intrinsic_nomem;
  1240.         bld_base->op_actions[TGSI_OPCODE_IABS].intr_name = "llvm.AMDIL.abs.";
  1241.         bld_base->op_actions[TGSI_OPCODE_IDIV].emit = emit_idiv;
  1242.         bld_base->op_actions[TGSI_OPCODE_IF].emit = if_emit;
  1243.         bld_base->op_actions[TGSI_OPCODE_UIF].emit = uif_emit;
  1244.         bld_base->op_actions[TGSI_OPCODE_IMAX].emit = build_tgsi_intrinsic_nomem;
  1245.         bld_base->op_actions[TGSI_OPCODE_IMAX].intr_name = "llvm.AMDGPU.imax";
  1246.         bld_base->op_actions[TGSI_OPCODE_IMIN].emit = build_tgsi_intrinsic_nomem;
  1247.         bld_base->op_actions[TGSI_OPCODE_IMIN].intr_name = "llvm.AMDGPU.imin";
  1248.         bld_base->op_actions[TGSI_OPCODE_INEG].emit = emit_ineg;
  1249.         bld_base->op_actions[TGSI_OPCODE_ISHR].emit = emit_ishr;
  1250.         bld_base->op_actions[TGSI_OPCODE_ISGE].emit = emit_icmp;
  1251.         bld_base->op_actions[TGSI_OPCODE_ISLT].emit = emit_icmp;
  1252.         bld_base->op_actions[TGSI_OPCODE_ISSG].emit = emit_ssg;
  1253.         bld_base->op_actions[TGSI_OPCODE_I2F].emit = emit_i2f;
  1254.         bld_base->op_actions[TGSI_OPCODE_KILL_IF].emit = kil_emit;
  1255.         bld_base->op_actions[TGSI_OPCODE_KILL_IF].intr_name = "llvm.AMDGPU.kill";
  1256.         bld_base->op_actions[TGSI_OPCODE_KILL].emit = lp_build_tgsi_intrinsic;
  1257.         bld_base->op_actions[TGSI_OPCODE_KILL].intr_name = "llvm.AMDGPU.kilp";
  1258.         bld_base->op_actions[TGSI_OPCODE_LG2].emit = build_tgsi_intrinsic_readonly;
  1259.         bld_base->op_actions[TGSI_OPCODE_LG2].intr_name = "llvm.log2.f32";
  1260.         bld_base->op_actions[TGSI_OPCODE_LRP].emit = build_tgsi_intrinsic_nomem;
  1261.         bld_base->op_actions[TGSI_OPCODE_LRP].intr_name = "llvm.AMDGPU.lrp";
  1262.         bld_base->op_actions[TGSI_OPCODE_MOD].emit = emit_mod;
  1263.         bld_base->op_actions[TGSI_OPCODE_NOT].emit = emit_not;
  1264.         bld_base->op_actions[TGSI_OPCODE_OR].emit = emit_or;
  1265.         bld_base->op_actions[TGSI_OPCODE_POW].emit = build_tgsi_intrinsic_readonly;
  1266.         bld_base->op_actions[TGSI_OPCODE_POW].intr_name = "llvm.pow.f32";
  1267.         bld_base->op_actions[TGSI_OPCODE_ROUND].emit = build_tgsi_intrinsic_nomem;
  1268.         bld_base->op_actions[TGSI_OPCODE_ROUND].intr_name = "llvm.AMDIL.round.nearest.";
  1269.         bld_base->op_actions[TGSI_OPCODE_SGE].emit = emit_cmp;
  1270.         bld_base->op_actions[TGSI_OPCODE_SEQ].emit = emit_cmp;
  1271.         bld_base->op_actions[TGSI_OPCODE_SHL].emit = emit_shl;
  1272.         bld_base->op_actions[TGSI_OPCODE_SLE].emit = emit_cmp;
  1273.         bld_base->op_actions[TGSI_OPCODE_SLT].emit = emit_cmp;
  1274.         bld_base->op_actions[TGSI_OPCODE_SNE].emit = emit_cmp;
  1275.         bld_base->op_actions[TGSI_OPCODE_SGT].emit = emit_cmp;
  1276.         bld_base->op_actions[TGSI_OPCODE_SIN].emit = build_tgsi_intrinsic_readonly;
  1277.         bld_base->op_actions[TGSI_OPCODE_SIN].intr_name = "llvm.sin.f32";
  1278.         bld_base->op_actions[TGSI_OPCODE_SSG].emit = emit_ssg;
  1279.         bld_base->op_actions[TGSI_OPCODE_TEX].fetch_args = tex_fetch_args;
  1280.         bld_base->op_actions[TGSI_OPCODE_TEX].intr_name = "llvm.AMDGPU.tex";
  1281.         bld_base->op_actions[TGSI_OPCODE_TEX2].fetch_args = tex_fetch_args;
  1282.         bld_base->op_actions[TGSI_OPCODE_TEX2].intr_name = "llvm.AMDGPU.tex";
  1283.         bld_base->op_actions[TGSI_OPCODE_TXB].fetch_args = tex_fetch_args;
  1284.         bld_base->op_actions[TGSI_OPCODE_TXB].intr_name = "llvm.AMDGPU.txb";
  1285.         bld_base->op_actions[TGSI_OPCODE_TXB2].fetch_args = tex_fetch_args;
  1286.         bld_base->op_actions[TGSI_OPCODE_TXB2].intr_name = "llvm.AMDGPU.txb";
  1287.         bld_base->op_actions[TGSI_OPCODE_TXD].fetch_args = txd_fetch_args;
  1288.         bld_base->op_actions[TGSI_OPCODE_TXD].intr_name = "llvm.AMDGPU.txd";
  1289.         bld_base->op_actions[TGSI_OPCODE_TXF].fetch_args = txf_fetch_args;
  1290.         bld_base->op_actions[TGSI_OPCODE_TXF].intr_name = "llvm.AMDGPU.txf";
  1291.         bld_base->op_actions[TGSI_OPCODE_TXL].fetch_args = tex_fetch_args;
  1292.         bld_base->op_actions[TGSI_OPCODE_TXL].intr_name = "llvm.AMDGPU.txl";
  1293.         bld_base->op_actions[TGSI_OPCODE_TXL2].fetch_args = tex_fetch_args;
  1294.         bld_base->op_actions[TGSI_OPCODE_TXL2].intr_name = "llvm.AMDGPU.txl";
  1295.         bld_base->op_actions[TGSI_OPCODE_TXP].fetch_args = txp_fetch_args;
  1296.         bld_base->op_actions[TGSI_OPCODE_TXP].intr_name = "llvm.AMDGPU.tex";
  1297.         bld_base->op_actions[TGSI_OPCODE_TXQ].fetch_args = tex_fetch_args;
  1298.         bld_base->op_actions[TGSI_OPCODE_TXQ].intr_name = "llvm.AMDGPU.txq";
  1299.         bld_base->op_actions[TGSI_OPCODE_TRUNC].emit = build_tgsi_intrinsic_nomem;
  1300.         bld_base->op_actions[TGSI_OPCODE_TRUNC].intr_name = "llvm.AMDGPU.trunc";
  1301.         bld_base->op_actions[TGSI_OPCODE_UADD].emit = emit_uadd;
  1302.         bld_base->op_actions[TGSI_OPCODE_UDIV].emit = emit_udiv;
  1303.         bld_base->op_actions[TGSI_OPCODE_UMAX].emit = build_tgsi_intrinsic_nomem;
  1304.         bld_base->op_actions[TGSI_OPCODE_UMAX].intr_name = "llvm.AMDGPU.umax";
  1305.         bld_base->op_actions[TGSI_OPCODE_UMIN].emit = build_tgsi_intrinsic_nomem;
  1306.         bld_base->op_actions[TGSI_OPCODE_UMIN].intr_name = "llvm.AMDGPU.umin";
  1307.         bld_base->op_actions[TGSI_OPCODE_UMOD].emit = emit_umod;
  1308.         bld_base->op_actions[TGSI_OPCODE_USEQ].emit = emit_icmp;
  1309.         bld_base->op_actions[TGSI_OPCODE_USGE].emit = emit_icmp;
  1310.         bld_base->op_actions[TGSI_OPCODE_USHR].emit = emit_ushr;
  1311.         bld_base->op_actions[TGSI_OPCODE_USLT].emit = emit_icmp;
  1312.         bld_base->op_actions[TGSI_OPCODE_USNE].emit = emit_icmp;
  1313.         bld_base->op_actions[TGSI_OPCODE_U2F].emit = emit_u2f;
  1314.         bld_base->op_actions[TGSI_OPCODE_XOR].emit = emit_xor;
  1315.         bld_base->op_actions[TGSI_OPCODE_UCMP].emit = emit_ucmp;
  1316.  
  1317.         bld_base->rsq_action.emit = build_tgsi_intrinsic_nomem;
  1318.         bld_base->rsq_action.intr_name = "llvm.AMDGPU.rsq";
  1319. }
  1320.  
  1321. void radeon_llvm_create_func(struct radeon_llvm_context * ctx,
  1322.                              LLVMTypeRef *ParamTypes, unsigned ParamCount)
  1323. {
  1324.         LLVMTypeRef main_fn_type;
  1325.         LLVMBasicBlockRef main_fn_body;
  1326.  
  1327.         /* Setup the function */
  1328.         main_fn_type = LLVMFunctionType(LLVMVoidTypeInContext(ctx->gallivm.context),
  1329.                                         ParamTypes, ParamCount, 0);
  1330.         ctx->main_fn = LLVMAddFunction(ctx->gallivm.module, "main", main_fn_type);
  1331.         main_fn_body = LLVMAppendBasicBlockInContext(ctx->gallivm.context,
  1332.                         ctx->main_fn, "main_body");
  1333.         LLVMPositionBuilderAtEnd(ctx->gallivm.builder, main_fn_body);
  1334. }
  1335.  
  1336. void radeon_llvm_finalize_module(struct radeon_llvm_context * ctx)
  1337. {
  1338.         struct gallivm_state * gallivm = ctx->soa.bld_base.base.gallivm;
  1339.         /* End the main function with Return*/
  1340.         LLVMBuildRetVoid(gallivm->builder);
  1341.  
  1342.         /* Create the pass manager */
  1343.         ctx->gallivm.passmgr = LLVMCreateFunctionPassManagerForModule(
  1344.                                                         gallivm->module);
  1345.  
  1346.         /* This pass should eliminate all the load and store instructions */
  1347.         LLVMAddPromoteMemoryToRegisterPass(gallivm->passmgr);
  1348.  
  1349.         /* Add some optimization passes */
  1350.         LLVMAddScalarReplAggregatesPass(gallivm->passmgr);
  1351.         LLVMAddLICMPass(gallivm->passmgr);
  1352.         LLVMAddAggressiveDCEPass(gallivm->passmgr);
  1353.         LLVMAddCFGSimplificationPass(gallivm->passmgr);
  1354.  
  1355.         /* Run the passs */
  1356.         LLVMRunFunctionPassManager(gallivm->passmgr, ctx->main_fn);
  1357.  
  1358.         LLVMDisposeBuilder(gallivm->builder);
  1359.         LLVMDisposePassManager(gallivm->passmgr);
  1360.  
  1361. }
  1362.  
  1363. void radeon_llvm_dispose(struct radeon_llvm_context * ctx)
  1364. {
  1365.         LLVMDisposeModule(ctx->soa.bld_base.base.gallivm->module);
  1366.         LLVMContextDispose(ctx->soa.bld_base.base.gallivm->context);
  1367. }
  1368.