src/gallium/drivers/radeonsi/radeonsi_shader.c

   1
   2 /*
   3  * Copyright 2012 Advanced Micro Devices, Inc.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * on the rights to use, copy, modify, merge, publish, distribute, sub
   9  * license, and/or sell copies of the Software, and to permit persons to whom
  10  * the Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  22  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *      Tom Stellard <thomas.stellard@amd.com>
  26  *      Michel Dänzer <michel.daenzer@amd.com>
  27  *      Christian König <christian.koenig@amd.com>
  28  */
  29
  30 #include "gallivm/lp_bld_tgsi_action.h"
  31 #include "gallivm/lp_bld_const.h"
  32 #include "gallivm/lp_bld_gather.h"
  33 #include "gallivm/lp_bld_intr.h"
  34 #include "gallivm/lp_bld_tgsi.h"
  35 #include "radeon_llvm.h"
  36 #include "radeon_llvm_emit.h"
  37 #include "tgsi/tgsi_info.h"
  38 #include "tgsi/tgsi_parse.h"
  39 #include "tgsi/tgsi_scan.h"
  40 #include "tgsi/tgsi_dump.h"
  41
  42 #include "radeonsi_pipe.h"
  43 #include "radeonsi_shader.h"
  44 #include "si_state.h"
  45 #include "sid.h"
  46
  47 #include <assert.h>
  48 #include <errno.h>
  49 #include <stdio.h>
  50
  51 /*
  52 static ps_remap_inputs(
  53         struct tgsi_llvm_context * tl_ctx,
  54         unsigned tgsi_index,
  55         unsigned tgsi_chan)
  56 {
  57         :
  58 }
  59
  60 struct si_input
  61 {
  62         struct list_head head;
  63         unsigned tgsi_index;
  64         unsigned tgsi_chan;
  65         unsigned order;
  66 };
  67 */
  68
  69
  70 struct si_shader_context
  71 {
  72         struct radeon_llvm_context radeon_bld;
  73         struct r600_context *rctx;
  74         struct tgsi_parse_context parse;
  75         struct tgsi_token * tokens;
  76         struct si_pipe_shader *shader;
  77         unsigned type; /* TGSI_PROCESSOR_* specifies the type of shader. */
  78         unsigned ninput_emitted;
  79 /*      struct list_head inputs; */
  80 /*      unsigned * input_mappings *//* From TGSI to SI hw */
  81 /*      struct tgsi_shader_info info;*/
  82 };
  83
  84 static struct si_shader_context * si_shader_context(
  85         struct lp_build_tgsi_context * bld_base)
  86 {
  87         return (struct si_shader_context *)bld_base;
  88 }
  89
  90
  91 #define PERSPECTIVE_BASE 0
  92 #define LINEAR_BASE 9
  93
  94 #define SAMPLE_OFFSET 0
  95 #define CENTER_OFFSET 2
  96 #define CENTROID_OFSET 4
  97
  98 #define USE_SGPR_MAX_SUFFIX_LEN 5
  99 #define CONST_ADDR_SPACE 2
 100 #define USER_SGPR_ADDR_SPACE 8
 101
 102 enum sgpr_type {
 103         SGPR_CONST_PTR_F32,
 104         SGPR_CONST_PTR_V4I32,
 105         SGPR_CONST_PTR_V8I32,
 106         SGPR_I32,
 107         SGPR_I64
 108 };
 109
 110 /**
 111  * Build an LLVM bytecode indexed load using LLVMBuildGEP + LLVMBuildLoad
 112  *
 113  * @param offset The offset parameter specifies the number of
 114  * elements to offset, not the number of bytes or dwords.  An element is the
 115  * the type pointed to by the base_ptr parameter (e.g. int is the element of
 116  * an int* pointer)
 117  *
 118  * When LLVM lowers the load instruction, it will convert the element offset
 119  * into a dword offset automatically.
 120  *
 121  */
 122 static LLVMValueRef build_indexed_load(
 123         struct gallivm_state * gallivm,
 124         LLVMValueRef base_ptr,
 125         LLVMValueRef offset)
 126 {
 127         LLVMValueRef computed_ptr = LLVMBuildGEP(
 128                 gallivm->builder, base_ptr, &offset, 1, "");
 129
 130         return LLVMBuildLoad(gallivm->builder, computed_ptr, "");
 131 }
 132
 133 /**
 134  * Load a value stored in one of the user SGPRs
 135  *
 136  * @param sgpr This is the sgpr to load the value from.  If you need to load a
 137  * value that is stored in consecutive SGPR registers (e.g. a 64-bit pointer),
 138  * then you should pass the index of the first SGPR that holds the value.  For
 139  * example, if you want to load a pointer that is stored in SGPRs 2 and 3, then
 140  * use pass 2 for the sgpr parameter.
 141  *
 142  * The value of the sgpr parameter must also be aligned to the width of the type
 143  * being loaded, so that the sgpr parameter is divisible by the dword width of the
 144  * type.  For example, if the value being loaded is two dwords wide, then the sgpr
 145  * parameter must be divisible by two.
 146  */
 147 static LLVMValueRef use_sgpr(
 148         struct gallivm_state * gallivm,
 149         enum sgpr_type type,
 150         unsigned sgpr)
 151 {
 152         LLVMValueRef sgpr_index;
 153         LLVMTypeRef ret_type;
 154         LLVMValueRef ptr;
 155
 156         sgpr_index = lp_build_const_int32(gallivm, sgpr);
 157
 158         switch (type) {
 159         case SGPR_CONST_PTR_F32:
 160                 assert(sgpr % 2 == 0);
 161                 ret_type = LLVMFloatTypeInContext(gallivm->context);
 162                 ret_type = LLVMPointerType(ret_type, CONST_ADDR_SPACE);
 163                 break;
 164
 165         case SGPR_I32:
 166                 ret_type = LLVMInt32TypeInContext(gallivm->context);
 167                 break;
 168
 169         case SGPR_I64:
 170                 assert(sgpr % 2 == 0);
 171                 ret_type= LLVMInt64TypeInContext(gallivm->context);
 172                 break;
 173
 174         case SGPR_CONST_PTR_V4I32:
 175                 assert(sgpr % 2 == 0);
 176                 ret_type = LLVMInt32TypeInContext(gallivm->context);
 177                 ret_type = LLVMVectorType(ret_type, 4);
 178                 ret_type = LLVMPointerType(ret_type, CONST_ADDR_SPACE);
 179                 break;
 180
 181         case SGPR_CONST_PTR_V8I32:
 182                 assert(sgpr % 2 == 0);
 183                 ret_type = LLVMInt32TypeInContext(gallivm->context);
 184                 ret_type = LLVMVectorType(ret_type, 8);
 185                 ret_type = LLVMPointerType(ret_type, CONST_ADDR_SPACE);
 186                 break;
 187
 188         default:
 189                 assert(!"Unsupported SGPR type in use_sgpr()");
 190                 return NULL;
 191         }
 192
 193         ret_type = LLVMPointerType(ret_type, USER_SGPR_ADDR_SPACE);
 194         ptr = LLVMBuildIntToPtr(gallivm->builder, sgpr_index, ret_type, "");
 195         return LLVMBuildLoad(gallivm->builder, ptr, "");
 196 }
 197
 198 static void declare_input_vs(
 199         struct si_shader_context * si_shader_ctx,
 200         unsigned input_index,
 201         const struct tgsi_full_declaration *decl)
 202 {
 203         LLVMValueRef t_list_ptr;
 204         LLVMValueRef t_offset;
 205         LLVMValueRef t_list;
 206         LLVMValueRef attribute_offset;
 207         LLVMValueRef buffer_index_reg;
 208         LLVMValueRef args[3];
 209         LLVMTypeRef vec4_type;
 210         LLVMValueRef input;
 211         struct lp_build_context * uint = &si_shader_ctx->radeon_bld.soa.bld_base.uint_bld;
 212         struct lp_build_context * base = &si_shader_ctx->radeon_bld.soa.bld_base.base;
 213         struct r600_context *rctx = si_shader_ctx->rctx;
 214         //struct pipe_vertex_element *velem = &rctx->vertex_elements->elements[input_index];
 215         unsigned chan;
 216
 217         /* Load the T list */
 218         /* XXX: Communicate with the rest of the driver about which SGPR the T#
 219          * list pointer is going to be stored in.  Hard code to SGPR[6:7] for
 220          * now */
 221         t_list_ptr = use_sgpr(base->gallivm, SGPR_CONST_PTR_V4I32, 6);
 222
 223         t_offset = lp_build_const_int32(base->gallivm, input_index);
 224
 225         t_list = build_indexed_load(base->gallivm, t_list_ptr, t_offset);
 226
 227         /* Build the attribute offset */
 228         attribute_offset = lp_build_const_int32(base->gallivm, 0);
 229
 230         /* Load the buffer index is always, which is always stored in VGPR0
 231          * for Vertex Shaders */
 232         buffer_index_reg = build_intrinsic(base->gallivm->builder,
 233                 "llvm.SI.vs.load.buffer.index", uint->elem_type, NULL, 0,
 234                 LLVMReadNoneAttribute);
 235
 236         vec4_type = LLVMVectorType(base->elem_type, 4);
 237         args[0] = t_list;
 238         args[1] = attribute_offset;
 239         args[2] = buffer_index_reg;
 240         input = lp_build_intrinsic(base->gallivm->builder,
 241                 "llvm.SI.vs.load.input", vec4_type, args, 3);
 242
 243         /* Break up the vec4 into individual components */
 244         for (chan = 0; chan < 4; chan++) {
 245                 LLVMValueRef llvm_chan = lp_build_const_int32(base->gallivm, chan);
 246                 /* XXX: Use a helper function for this.  There is one in
 247                  * tgsi_llvm.c. */
 248                 si_shader_ctx->radeon_bld.inputs[radeon_llvm_reg_index_soa(input_index, chan)] =
 249                                 LLVMBuildExtractElement(base->gallivm->builder,
 250                                 input, llvm_chan, "");
 251         }
 252 }
 253
 254 static void declare_input_fs(
 255         struct si_shader_context * si_shader_ctx,
 256         unsigned input_index,
 257         const struct tgsi_full_declaration *decl)
 258 {
 259         const char * intr_name;
 260         unsigned chan;
 261         struct lp_build_context * base =
 262                                 &si_shader_ctx->radeon_bld.soa.bld_base.base;
 263         struct gallivm_state * gallivm = base->gallivm;
 264
 265         /* This value is:
 266          * [15:0] NewPrimMask (Bit mask for each quad.  It is set it the
 267          *                     quad begins a new primitive.  Bit 0 always needs
 268          *                     to be unset)
 269          * [32:16] ParamOffset
 270          *
 271          */
 272         /* XXX: This register number must be identical to the S_00B02C_USER_SGPR
 273          * register field value
 274          */
 275         LLVMValueRef params = use_sgpr(base->gallivm, SGPR_I32, 6);
 276
 277
 278         /* XXX: Is this the input_index? */
 279         LLVMValueRef attr_number = lp_build_const_int32(gallivm, input_index);
 280
 281         /* XXX: Handle all possible interpolation modes */
 282         switch (decl->Interp.Interpolate) {
 283         case TGSI_INTERPOLATE_COLOR:
 284                 /* XXX: Flat shading hangs the GPU */
 285                 if (si_shader_ctx->rctx->queued.named.rasterizer &&
 286                     si_shader_ctx->rctx->queued.named.rasterizer->flatshade) {
 287 #if 0
 288                         intr_name = "llvm.SI.fs.interp.constant";
 289 #else
 290                         intr_name = "llvm.SI.fs.interp.linear.center";
 291 #endif
 292                 } else {
 293                         if (decl->Interp.Centroid)
 294                                 intr_name = "llvm.SI.fs.interp.persp.centroid";
 295                         else
 296                                 intr_name = "llvm.SI.fs.interp.persp.center";
 297                 }
 298                 break;
 299         case TGSI_INTERPOLATE_CONSTANT:
 300                 /* XXX: Flat shading hangs the GPU */
 301 #if 0
 302                 intr_name = "llvm.SI.fs.interp.constant";
 303                 break;
 304 #endif
 305         case TGSI_INTERPOLATE_LINEAR:
 306                 if (decl->Interp.Centroid)
 307                         intr_name = "llvm.SI.fs.interp.linear.centroid";
 308                 else
 309                         intr_name = "llvm.SI.fs.interp.linear.center";
 310                 break;
 311         case TGSI_INTERPOLATE_PERSPECTIVE:
 312                 if (decl->Interp.Centroid)
 313                         intr_name = "llvm.SI.fs.interp.persp.centroid";
 314                 else
 315                         intr_name = "llvm.SI.fs.interp.persp.center";
 316                 break;
 317         default:
 318                 fprintf(stderr, "Warning: Unhandled interpolation mode.\n");
 319                 return;
 320         }
 321
 322         if (!si_shader_ctx->ninput_emitted++) {
 323                 /* Enable whole quad mode */
 324                 lp_build_intrinsic(gallivm->builder,
 325                                    "llvm.SI.wqm",
 326                                    LLVMVoidTypeInContext(gallivm->context),
 327                                    NULL, 0);
 328         }
 329
 330         /* XXX: Could there be more than TGSI_NUM_CHANNELS (4) ? */
 331         for (chan = 0; chan < TGSI_NUM_CHANNELS; chan++) {
 332                 LLVMValueRef args[3];
 333                 LLVMValueRef llvm_chan = lp_build_const_int32(gallivm, chan);
 334                 unsigned soa_index = radeon_llvm_reg_index_soa(input_index, chan);
 335                 LLVMTypeRef input_type = LLVMFloatTypeInContext(gallivm->context);
 336                 args[0] = llvm_chan;
 337                 args[1] = attr_number;
 338                 args[2] = params;
 339                 si_shader_ctx->radeon_bld.inputs[soa_index] =
 340                         build_intrinsic(base->gallivm->builder, intr_name,
 341                                 input_type, args, 3, LLVMReadOnlyAttribute);
 342         }
 343 }
 344
 345 static void declare_input(
 346         struct radeon_llvm_context * radeon_bld,
 347         unsigned input_index,
 348         const struct tgsi_full_declaration *decl)
 349 {
 350         struct si_shader_context * si_shader_ctx =
 351                                 si_shader_context(&radeon_bld->soa.bld_base);
 352         if (si_shader_ctx->type == TGSI_PROCESSOR_VERTEX) {
 353                 declare_input_vs(si_shader_ctx, input_index, decl);
 354         } else if (si_shader_ctx->type == TGSI_PROCESSOR_FRAGMENT) {
 355                 declare_input_fs(si_shader_ctx, input_index, decl);
 356         } else {
 357                 fprintf(stderr, "Warning: Unsupported shader type,\n");
 358         }
 359 }
 360
 361 static LLVMValueRef fetch_constant(
 362         struct lp_build_tgsi_context * bld_base,
 363         const struct tgsi_full_src_register *reg,
 364         enum tgsi_opcode_type type,
 365         unsigned swizzle)
 366 {
 367         struct lp_build_context * base = &bld_base->base;
 368         unsigned idx;
 369
 370         LLVMValueRef const_ptr;
 371         LLVMValueRef offset;
 372         LLVMValueRef load;
 373
 374         /* currently not supported */
 375         if (reg->Register.Indirect) {
 376                 assert(0);
 377                 load = lp_build_const_int32(base->gallivm, 0);
 378                 return bitcast(bld_base, type, load);
 379         }
 380
 381         /* XXX: Assume the pointer to the constant buffer is being stored in
 382          * SGPR[0:1] */
 383         const_ptr = use_sgpr(base->gallivm, SGPR_CONST_PTR_F32, 0);
 384
 385         /* XXX: This assumes that the constant buffer is not packed, so
 386          * CONST[0].x will have an offset of 0 and CONST[1].x will have an
 387          * offset of 4. */
 388         idx = (reg->Register.Index * 4) + swizzle;
 389
 390         /* index loads above 255 are currently not supported */
 391         if (idx > 255) {
 392                 assert(0);
 393                 idx = 0;
 394         }
 395         offset = lp_build_const_int32(base->gallivm, idx);
 396
 397         load = build_indexed_load(base->gallivm, const_ptr, offset);
 398         return bitcast(bld_base, type, load);
 399 }
 400
 401 /* Initialize arguments for the shader export intrinsic */
 402 static void si_llvm_init_export_args(struct lp_build_tgsi_context *bld_base,
 403                                      struct tgsi_full_declaration *d,
 404                                      unsigned index,
 405                                      unsigned target,
 406                                      LLVMValueRef *args)
 407 {
 408         struct si_shader_context *si_shader_ctx = si_shader_context(bld_base);
 409         struct lp_build_context *uint =
 410                                 &si_shader_ctx->radeon_bld.soa.bld_base.uint_bld;
 411         struct lp_build_context *base = &bld_base->base;
 412         unsigned compressed = 0;
 413         unsigned chan;
 414
 415         if (si_shader_ctx->type == TGSI_PROCESSOR_FRAGMENT) {
 416                 int cbuf = target - V_008DFC_SQ_EXP_MRT;
 417
 418                 if (cbuf >= 0 && cbuf < 8) {
 419                         struct r600_context *rctx = si_shader_ctx->rctx;
 420                         compressed = (rctx->export_16bpc >> cbuf) & 0x1;
 421                 }
 422         }
 423
 424         if (compressed) {
 425                 /* Pixel shader needs to pack output values before export */
 426                 for (chan = 0; chan < 2; chan++ ) {
 427                         LLVMValueRef *out_ptr =
 428                                 si_shader_ctx->radeon_bld.soa.outputs[index];
 429                         args[0] = LLVMBuildLoad(base->gallivm->builder,
 430                                                 out_ptr[2 * chan], "");
 431                         args[1] = LLVMBuildLoad(base->gallivm->builder,
 432                                                 out_ptr[2 * chan + 1], "");
 433                         args[chan + 5] =
 434                                 build_intrinsic(base->gallivm->builder,
 435                                                 "llvm.SI.packf16",
 436                                                 LLVMInt32TypeInContext(base->gallivm->context),
 437                                                 args, 2,
 438                                                 LLVMReadNoneAttribute);
 439                         args[chan + 7] = args[chan + 5];
 440                 }
 441
 442                 /* Set COMPR flag */
 443                 args[4] = uint->one;
 444         } else {
 445                 for (chan = 0; chan < 4; chan++ ) {
 446                         LLVMValueRef out_ptr =
 447                                 si_shader_ctx->radeon_bld.soa.outputs[index][chan];
 448                         /* +5 because the first output value will be
 449                          * the 6th argument to the intrinsic. */
 450                         args[chan + 5] = LLVMBuildLoad(base->gallivm->builder,
 451                                                        out_ptr, "");
 452                 }
 453
 454                 /* Clear COMPR flag */
 455                 args[4] = uint->zero;
 456         }
 457
 458         /* XXX: This controls which components of the output
 459          * registers actually get exported. (e.g bit 0 means export
 460          * X component, bit 1 means export Y component, etc.)  I'm
 461          * hard coding this to 0xf for now.  In the future, we might
 462          * want to do something else. */
 463         args[0] = lp_build_const_int32(base->gallivm, 0xf);
 464
 465         /* Specify whether the EXEC mask represents the valid mask */
 466         args[1] = uint->zero;
 467
 468         /* Specify whether this is the last export */
 469         args[2] = uint->zero;
 470
 471         /* Specify the target we are exporting */
 472         args[3] = lp_build_const_int32(base->gallivm, target);
 473
 474         /* XXX: We probably need to keep track of the output
 475          * values, so we know what we are passing to the next
 476          * stage. */
 477 }
 478
 479 /* XXX: This is partially implemented for VS only at this point.  It is not complete */
 480 static void si_llvm_emit_epilogue(struct lp_build_tgsi_context * bld_base)
 481 {
 482         struct si_shader_context * si_shader_ctx = si_shader_context(bld_base);
 483         struct si_shader * shader = &si_shader_ctx->shader->shader;
 484         struct lp_build_context * base = &bld_base->base;
 485         struct lp_build_context * uint =
 486                                 &si_shader_ctx->radeon_bld.soa.bld_base.uint_bld;
 487         struct tgsi_parse_context *parse = &si_shader_ctx->parse;
 488         LLVMValueRef last_args[9] = { 0 };
 489         unsigned color_count = 0;
 490         unsigned param_count = 0;
 491
 492         while (!tgsi_parse_end_of_tokens(parse)) {
 493                 struct tgsi_full_declaration *d =
 494                                         &parse->FullToken.FullDeclaration;
 495                 LLVMValueRef args[9];
 496                 unsigned target;
 497                 unsigned index;
 498                 int i;
 499
 500                 tgsi_parse_token(parse);
 501                 if (parse->FullToken.Token.Type != TGSI_TOKEN_TYPE_DECLARATION)
 502                         continue;
 503
 504                 switch (d->Declaration.File) {
 505                 case TGSI_FILE_INPUT:
 506                         i = shader->ninput++;
 507                         shader->input[i].name = d->Semantic.Name;
 508                         shader->input[i].sid = d->Semantic.Index;
 509                         shader->input[i].interpolate = d->Interp.Interpolate;
 510                         shader->input[i].centroid = d->Interp.Centroid;
 511                         continue;
 512
 513                 case TGSI_FILE_OUTPUT:
 514                         i = shader->noutput++;
 515                         shader->output[i].name = d->Semantic.Name;
 516                         shader->output[i].sid = d->Semantic.Index;
 517                         shader->output[i].interpolate = d->Interp.Interpolate;
 518                         break;
 519
 520                 default:
 521                         continue;
 522                 }
 523
 524                 for (index = d->Range.First; index <= d->Range.Last; index++) {
 525                         /* Select the correct target */
 526                         switch(d->Semantic.Name) {
 527                         case TGSI_SEMANTIC_PSIZE:
 528                         case TGSI_SEMANTIC_POSITION:
 529                                 target = V_008DFC_SQ_EXP_POS;
 530                                 break;
 531                         case TGSI_SEMANTIC_COLOR:
 532                                 if (si_shader_ctx->type == TGSI_PROCESSOR_VERTEX) {
 533                                         target = V_008DFC_SQ_EXP_PARAM + param_count;
 534                                         shader->output[i].param_offset = param_count;
 535                                         param_count++;
 536                                 } else {
 537                                         target = V_008DFC_SQ_EXP_MRT + color_count;
 538                                         color_count++;
 539                                 }
 540                                 break;
 541                         case TGSI_SEMANTIC_GENERIC:
 542                                 target = V_008DFC_SQ_EXP_PARAM + param_count;
 543                                 shader->output[i].param_offset = param_count;
 544                                 param_count++;
 545                                 break;
 546                         default:
 547                                 target = 0;
 548                                 fprintf(stderr,
 549                                         "Warning: SI unhandled output type:%d\n",
 550                                         d->Semantic.Name);
 551                         }
 552
 553                         si_llvm_init_export_args(bld_base, d, index, target, args);
 554
 555                         if (si_shader_ctx->type == TGSI_PROCESSOR_VERTEX ?
 556                             (d->Semantic.Name == TGSI_SEMANTIC_POSITION) :
 557                             (d->Semantic.Name == TGSI_SEMANTIC_COLOR)) {
 558                                 if (last_args[0]) {
 559                                         lp_build_intrinsic(base->gallivm->builder,
 560                                                            "llvm.SI.export",
 561                                                            LLVMVoidTypeInContext(base->gallivm->context),
 562                                                            last_args, 9);
 563                                 }
 564
 565                                 memcpy(last_args, args, sizeof(args));
 566                         } else {
 567                                 lp_build_intrinsic(base->gallivm->builder,
 568                                                    "llvm.SI.export",
 569                                                    LLVMVoidTypeInContext(base->gallivm->context),
 570                                                    args, 9);
 571                         }
 572
 573                 }
 574         }
 575
 576         if (!last_args[0]) {
 577                 assert(si_shader_ctx->type == TGSI_PROCESSOR_FRAGMENT);
 578
 579                 /* Specify which components to enable */
 580                 last_args[0] = lp_build_const_int32(base->gallivm, 0x0);
 581
 582                 /* Specify the target we are exporting */
 583                 last_args[3] = lp_build_const_int32(base->gallivm, V_008DFC_SQ_EXP_MRT);
 584
 585                 /* Set COMPR flag to zero to export data as 32-bit */
 586                 last_args[4] = uint->zero;
 587
 588                 /* dummy bits */
 589                 last_args[5]= uint->zero;
 590                 last_args[6]= uint->zero;
 591                 last_args[7]= uint->zero;
 592                 last_args[8]= uint->zero;
 593         }
 594
 595         /* Specify whether the EXEC mask represents the valid mask */
 596         last_args[1] = lp_build_const_int32(base->gallivm,
 597                                             si_shader_ctx->type == TGSI_PROCESSOR_FRAGMENT);
 598
 599         /* Specify that this is the last export */
 600         last_args[2] = lp_build_const_int32(base->gallivm, 1);
 601
 602         lp_build_intrinsic(base->gallivm->builder,
 603                            "llvm.SI.export",
 604                            LLVMVoidTypeInContext(base->gallivm->context),
 605                            last_args, 9);
 606
 607 /* XXX: Look up what this function does */
 608 /*              ctx->shader->output[i].spi_sid = r600_spi_sid(&ctx->shader->output[i]);*/
 609 }
 610
 611 static void tex_fetch_args(
 612         struct lp_build_tgsi_context * bld_base,
 613         struct lp_build_emit_data * emit_data)
 614 {
 615         const struct tgsi_full_instruction * inst = emit_data->inst;
 616         LLVMValueRef ptr;
 617         LLVMValueRef offset;
 618
 619         /* WriteMask */
 620         /* XXX: should be optimized using emit_data->inst->Dst[0].Register.WriteMask*/
 621         emit_data->args[0] = lp_build_const_int32(bld_base->base.gallivm, 0xf);
 622
 623         /* Coordinates */
 624         /* XXX: Not all sample instructions need 4 address arguments. */
 625         if (inst->Instruction.Opcode == TGSI_OPCODE_TXP) {
 626                 LLVMValueRef src_w;
 627                 unsigned chan;
 628                 LLVMValueRef coords[4];
 629
 630                 emit_data->dst_type = LLVMVectorType(bld_base->base.elem_type, 4);
 631                 src_w = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_W);
 632
 633                 for (chan = 0; chan < 3; chan++ ) {
 634                         LLVMValueRef arg = lp_build_emit_fetch(bld_base,
 635                                                                emit_data->inst, 0, chan);
 636                         coords[chan] = lp_build_emit_llvm_binary(bld_base,
 637                                                                  TGSI_OPCODE_DIV,
 638                                                                  arg, src_w);
 639                 }
 640                 coords[3] = bld_base->base.one;
 641                 emit_data->args[1] = lp_build_gather_values(bld_base->base.gallivm,
 642                                                             coords, 4);
 643         } else
 644                 emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst,
 645                                                          0, LP_CHAN_ALL);
 646
 647         /* Resource */
 648         ptr = use_sgpr(bld_base->base.gallivm, SGPR_CONST_PTR_V8I32, 4);
 649         offset = lp_build_const_int32(bld_base->base.gallivm,
 650                                   emit_data->inst->Src[1].Register.Index);
 651         emit_data->args[2] = build_indexed_load(bld_base->base.gallivm,
 652                                                 ptr, offset);
 653
 654         /* Sampler */
 655         ptr = use_sgpr(bld_base->base.gallivm, SGPR_CONST_PTR_V4I32, 2);
 656         offset = lp_build_const_int32(bld_base->base.gallivm,
 657                                   emit_data->inst->Src[1].Register.Index);
 658         emit_data->args[3] = build_indexed_load(bld_base->base.gallivm,
 659                                                 ptr, offset);
 660
 661         /* Dimensions */
 662         /* XXX: We might want to pass this information to the shader at some. */
 663 /*      emit_data->args[4] = lp_build_const_int32(bld_base->base.gallivm,
 664                                         emit_data->inst->Texture.Texture);
 665 */
 666
 667         emit_data->arg_count = 4;
 668         /* XXX: To optimize, we could use a float or v2f32, if the last bits of
 669          * the writemask are clear */
 670         emit_data->dst_type = LLVMVectorType(
 671                         LLVMFloatTypeInContext(bld_base->base.gallivm->context),
 672                         4);
 673 }
 674
 675 static const struct lp_build_tgsi_action tex_action = {
 676         .fetch_args = tex_fetch_args,
 677         .emit = lp_build_tgsi_intrinsic,
 678         .intr_name = "llvm.SI.sample"
 679 };
 680
 681
 682 int si_pipe_shader_create(
 683         struct pipe_context *ctx,
 684         struct si_pipe_shader *shader)
 685 {
 686         struct r600_context *rctx = (struct r600_context*)ctx;
 687         struct si_pipe_shader_selector *sel = shader->selector;
 688         struct si_shader_context si_shader_ctx;
 689         struct tgsi_shader_info shader_info;
 690         struct lp_build_tgsi_context * bld_base;
 691         LLVMModuleRef mod;
 692         unsigned char * inst_bytes;
 693         unsigned inst_byte_count;
 694         unsigned i;
 695         uint32_t *ptr;
 696         bool dump;
 697
 698         dump = debug_get_bool_option("RADEON_DUMP_SHADERS", FALSE);
 699
 700         memset(&si_shader_ctx, 0, sizeof(si_shader_ctx));
 701         radeon_llvm_context_init(&si_shader_ctx.radeon_bld);
 702         bld_base = &si_shader_ctx.radeon_bld.soa.bld_base;
 703
 704         tgsi_scan_shader(sel->tokens, &shader_info);
 705         bld_base->info = &shader_info;
 706         bld_base->emit_fetch_funcs[TGSI_FILE_CONSTANT] = fetch_constant;
 707         bld_base->emit_epilogue = si_llvm_emit_epilogue;
 708
 709         bld_base->op_actions[TGSI_OPCODE_TEX] = tex_action;
 710         bld_base->op_actions[TGSI_OPCODE_TXP] = tex_action;
 711
 712         si_shader_ctx.radeon_bld.load_input = declare_input;
 713         si_shader_ctx.tokens = sel->tokens;
 714         tgsi_parse_init(&si_shader_ctx.parse, si_shader_ctx.tokens);
 715         si_shader_ctx.shader = shader;
 716         si_shader_ctx.type = si_shader_ctx.parse.FullHeader.Processor.Processor;
 717         si_shader_ctx.rctx = rctx;
 718
 719         shader->shader.nr_cbufs = rctx->framebuffer.nr_cbufs;
 720
 721         /* Dump TGSI code before doing TGSI->LLVM conversion in case the
 722          * conversion fails. */
 723         if (dump) {
 724                 tgsi_dump(sel->tokens, 0);
 725         }
 726
 727         if (!lp_build_tgsi_llvm(bld_base, sel->tokens)) {
 728                 fprintf(stderr, "Failed to translate shader from TGSI to LLVM\n");
 729                 return -EINVAL;
 730         }
 731
 732         radeon_llvm_finalize_module(&si_shader_ctx.radeon_bld);
 733
 734         mod = bld_base->base.gallivm->module;
 735         if (dump) {
 736                 LLVMDumpModule(mod);
 737         }
 738         radeon_llvm_compile(mod, &inst_bytes, &inst_byte_count, "SI", dump);
 739         if (dump) {
 740                 fprintf(stderr, "SI CODE:\n");
 741                 for (i = 0; i < inst_byte_count; i+=4 ) {
 742                         fprintf(stderr, "%02x%02x%02x%02x\n", inst_bytes[i + 3],
 743                                 inst_bytes[i + 2], inst_bytes[i + 1],
 744                                 inst_bytes[i]);
 745                 }
 746         }
 747
 748         shader->num_sgprs = util_le32_to_cpu(*(uint32_t*)inst_bytes);
 749         shader->num_vgprs = util_le32_to_cpu(*(uint32_t*)(inst_bytes + 4));
 750         shader->spi_ps_input_ena = util_le32_to_cpu(*(uint32_t*)(inst_bytes + 8));
 751
 752         radeon_llvm_dispose(&si_shader_ctx.radeon_bld);
 753         tgsi_parse_free(&si_shader_ctx.parse);
 754
 755         /* copy new shader */
 756         si_resource_reference(&shader->bo, NULL);
 757         shader->bo = si_resource_create_custom(ctx->screen, PIPE_USAGE_IMMUTABLE,
 758                                                inst_byte_count - 12);
 759         if (shader->bo == NULL) {
 760                 return -ENOMEM;
 761         }
 762
 763         ptr = (uint32_t*)rctx->ws->buffer_map(shader->bo->cs_buf, rctx->cs, PIPE_TRANSFER_WRITE);
 764         if (0 /*R600_BIG_ENDIAN*/) {
 765                 for (i = 0; i < (inst_byte_count-12)/4; ++i) {
 766                         ptr[i] = util_bswap32(*(uint32_t*)(inst_bytes+12 + i*4));
 767                 }
 768         } else {
 769                 memcpy(ptr, inst_bytes + 12, inst_byte_count - 12);
 770         }
 771         rctx->ws->buffer_unmap(shader->bo->cs_buf);
 772
 773         free(inst_bytes);
 774
 775         return 0;
 776 }
 777
 778 void si_pipe_shader_destroy(struct pipe_context *ctx, struct si_pipe_shader *shader)
 779 {
 780         si_resource_reference(&shader->bo, NULL);
 781 }