gallivm: implement function calls

1 files changed, 437 insertions, 53 deletions

diff --git a/src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c
index fd532c63d6..3dfa6cf25c 100644
--- a/src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c
+++ b/src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c
@@ -38,6 +38,7 @@
 
 #include "pipe/p_config.h"
 #include "pipe/p_shader_tokens.h"
+#include "cso_cache/cso_hash.h"
 #include "util/u_debug.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"
@@ -97,6 +98,7 @@ struct lp_exec_mask {
    LLVMValueRef cont_mask;
    LLVMValueRef break_mask;
    LLVMValueRef break_var;
+   LLVMValueRef ret_mask;
    struct {
       LLVMBasicBlockRef loop_block;
       LLVMValueRef cont_mask;
@@ -117,23 +119,43 @@ struct lp_build_tgsi_soa_context
 
    LLVMValueRef consts_ptr;
    const LLVMValueRef *pos;
-   const LLVMValueRef (*inputs)[NUM_CHANNELS];
-   LLVMValueRef (*outputs)[NUM_CHANNELS];
 
    const struct lp_build_sampler_soa *sampler;
 
+   const LLVMValueRef (*inputs)[NUM_CHANNELS];
+   LLVMValueRef (*outputs)[NUM_CHANNELS];
    LLVMValueRef immediates[LP_MAX_TGSI_IMMEDIATES][NUM_CHANNELS];
    LLVMValueRef temps[LP_MAX_TGSI_TEMPS][NUM_CHANNELS];
    LLVMValueRef addr[LP_MAX_TGSI_ADDRS][NUM_CHANNELS];
    LLVMValueRef preds[LP_MAX_TGSI_PREDS][NUM_CHANNELS];
 
-   /* we allocate an array of temps if we have indirect
+   /* we allocate an array of allocas if we have indirect
     * addressing and then the temps above is unused */
    LLVMValueRef temps_array;
+
+   LLVMValueRef inputs_array;
+   LLVMValueRef outputs_array;
+   LLVMValueRef immediates_array;
+   LLVMValueRef addrs_array;
+   LLVMValueRef preds_array;
+
    boolean has_indirect_addressing;
+   boolean has_function_calls;
 
    struct lp_build_mask_context *mask;
    struct lp_exec_mask exec_mask;
+
+   struct cso_hash *func_hash;
+   unsigned instno;
+   LLVMBasicBlockRef main_block;
+
+   struct {
+      struct tgsi_declaration_range inputs;
+      struct tgsi_declaration_range outputs;
+      struct tgsi_declaration_range temps;
+      struct tgsi_declaration_range addrs;
+      struct tgsi_declaration_range preds;
+   } full_range;
 };
 
 static const unsigned char
@@ -160,12 +182,160 @@ swizzle_bottom[4] = {
    QUAD_BOTTOM_LEFT,  QUAD_BOTTOM_RIGHT
 };
 
+
+static LLVMValueRef
+get_temp_ptr(struct lp_build_tgsi_soa_context *bld,
+             unsigned index,
+             unsigned chan,
+             boolean is_indirect,
+             LLVMValueRef addr)
+{
+   assert(chan < 4);
+   if (!bld->has_indirect_addressing &&
+       !bld->has_function_calls) {
+      return bld->temps[index][chan];
+   } else {
+      LLVMValueRef lindex =
+         LLVMConstInt(LLVMInt32Type(), index * 4 + chan, 0);
+      if (is_indirect)
+         lindex = lp_build_add(&bld->base, lindex, addr);
+      return LLVMBuildGEP(bld->base.builder, bld->temps_array, &lindex, 1, "temp_ptr");
+   }
+}
+
+static LLVMValueRef
+get_input_ptr(struct lp_build_tgsi_soa_context *bld,
+             unsigned index,
+             unsigned swizzle,
+             boolean is_indirect,
+             LLVMValueRef addr)
+{
+   LLVMValueRef lindex =
+      LLVMConstInt(LLVMInt32Type(), index*4 + swizzle, 0);
+   assert(bld->has_function_calls);
+   if (is_indirect)
+      lindex = lp_build_add(&bld->base, lindex, addr);
+   return LLVMBuildGEP(bld->base.builder, bld->inputs_array, &lindex, 1, "input_ptr");
+}
+
+static LLVMValueRef
+get_output_ptr(struct lp_build_tgsi_soa_context *bld,
+             unsigned index,
+             unsigned swizzle,
+             boolean is_indirect,
+             LLVMValueRef addr)
+{
+   if (!bld->has_function_calls) {
+      return bld->outputs[index][swizzle];
+   } else {
+      LLVMValueRef lindex =
+         LLVMConstInt(LLVMInt32Type(), index*4 + swizzle, 0);
+      if (is_indirect)
+         lindex = lp_build_add(&bld->base, lindex, addr);
+      return LLVMBuildGEP(bld->base.builder, bld->outputs_array, &lindex, 1, "output_ptr");
+   }
+}
+
+static LLVMValueRef
+get_immediates_ptr(struct lp_build_tgsi_soa_context *bld,
+                   unsigned index,
+                   unsigned swizzle,
+                   boolean is_indirect,
+                   LLVMValueRef addr)
+{
+   LLVMValueRef lindex =
+      LLVMConstInt(LLVMInt32Type(), index*4 + swizzle, 0);
+   assert(bld->has_function_calls);
+   if (is_indirect)
+      lindex = lp_build_add(&bld->base, lindex, addr);
+   return LLVMBuildGEP(bld->base.builder, bld->immediates_array, &lindex, 1, "immediates_ptr");
+}
+
+static LLVMValueRef
+get_addr_ptr(struct lp_build_tgsi_soa_context *bld,
+             unsigned index,
+             unsigned swizzle,
+             boolean is_indirect,
+             LLVMValueRef addr)
+{
+   if (!bld->has_function_calls) {
+      return bld->addr[index][swizzle];
+   } else {
+      LLVMValueRef lindex =
+         LLVMConstInt(LLVMInt32Type(), index*4 + swizzle, 0);
+      if (is_indirect)
+         lindex = lp_build_add(&bld->base, lindex, addr);
+      return LLVMBuildGEP(bld->base.builder, bld->addrs_array, &lindex, 1, "addrs_ptr");
+   }
+}
+
+static LLVMValueRef
+get_preds_ptr(struct lp_build_tgsi_soa_context *bld,
+              unsigned index,
+              unsigned swizzle,
+              boolean is_indirect,
+              LLVMValueRef addr)
+{
+   if (!bld->has_function_calls) {
+      return bld->preds[index][swizzle];
+   } else {
+      LLVMValueRef lindex =
+         LLVMConstInt(LLVMInt32Type(), index*4 + swizzle, 0);
+      if (is_indirect)
+         lindex = lp_build_add(&bld->base, lindex, addr);
+      return LLVMBuildGEP(bld->base.builder, bld->preds_array, &lindex, 1, "preds_ptr");
+   }
+}
+
+static LLVMValueRef lp_get_function(struct lp_build_tgsi_soa_context *bld,
+                                    int label)
+{
+   struct cso_hash *hash = bld->func_hash;
+   struct cso_hash_iter iter = cso_hash_find(hash, label);
+   LLVMValueRef func;
+   LLVMModuleRef module = LLVMGetGlobalParent(
+      LLVMGetBasicBlockParent(LLVMGetInsertBlock(bld->base.builder)));
+
+   if (cso_hash_iter_is_null(iter)) {
+      LLVMTypeRef func_type;
+      LLVMTypeRef arg_types[7];
+      LLVMTypeRef vec_type = lp_build_vec_type(bld->base.type);
+      int i;
+      char func_name[32];
+
+      snprintf(func_name, 31, "func%d", label);
+
+      arg_types[0] = LLVMPointerType(vec_type, 0);  /* inputs */
+      arg_types[1] = LLVMPointerType(vec_type, 0);  /* outpus */
+      arg_types[2] = LLVMTypeOf(bld->consts_ptr);   /* consts */
+      arg_types[3] = LLVMPointerType(vec_type, 0);  /* temps */
+      arg_types[4] = LLVMPointerType(vec_type, 0);  /* addrs */
+      arg_types[5] = LLVMPointerType(vec_type, 0);  /* preds */
+      arg_types[6] = LLVMPointerType(vec_type, 0);  /* immediates */
+
+      func_type = LLVMFunctionType(LLVMVoidType(), arg_types, Elements(arg_types), 0);
+
+      func = LLVMAddFunction(module, func_name, func_type);
+      LLVMSetFunctionCallConv(func, LLVMCCallConv);
+      for(i = 0; i < Elements(arg_types); ++i)
+         if(LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind)
+            LLVMAddAttribute(LLVMGetParam(func, i), LLVMNoAliasAttribute);
+
+      cso_hash_insert(hash, label, func);
+   } else {
+      func = (LLVMValueRef)cso_hash_iter_data(iter);
+   }
+
+   return func;
+}
+
 static void lp_exec_mask_init(struct lp_exec_mask *mask, struct lp_build_context *bld)
 {
    mask->bld = bld;
    mask->has_mask = FALSE;
    mask->cond_stack_size = 0;
    mask->loop_stack_size = 0;
+   mask->ret_mask = 0;
 
    mask->int_vec_type = lp_build_int_vec_type(mask->bld->type);
    mask->break_mask = mask->cont_mask = mask->cond_mask =
@@ -189,9 +359,17 @@ static void lp_exec_mask_update(struct lp_exec_mask *mask)
    } else
       mask->exec_mask = mask->cond_mask;
 
+   if (mask->ret_mask) {
+      mask->exec_mask = LLVMBuildAnd(mask->bld->builder,
+                                     mask->exec_mask,
+                                     mask->ret_mask,
+                                     "retmask");
+   }
+
 
    mask->has_mask = (mask->cond_stack_size > 0 ||
-                     mask->loop_stack_size > 0);
+                     mask->loop_stack_size > 0 ||
+                     mask->ret_mask);
 }
 
 static void lp_exec_mask_cond_push(struct lp_exec_mask *mask,
@@ -234,6 +412,13 @@ static void lp_exec_mask_cond_pop(struct lp_exec_mask *mask)
    lp_exec_mask_update(mask);
 }
 
+
+static void lp_exec_bgnsub(struct lp_exec_mask *mask)
+{
+   mask->exec_mask = LLVMConstAllOnes(mask->int_vec_type);
+   mask->ret_mask = LLVMConstAllOnes(mask->int_vec_type);
+}
+
 static void lp_exec_bgnloop(struct lp_exec_mask *mask)
 {
    if (mask->loop_stack_size == 0) {
@@ -276,6 +461,21 @@ static void lp_exec_break(struct lp_exec_mask *mask)
    lp_exec_mask_update(mask);
 }
 
+
+static void lp_exec_ret(struct lp_exec_mask *mask)
+{
+   LLVMValueRef exec_mask = LLVMBuildNot(mask->bld->builder,
+                                         mask->exec_mask,
+                                         "ret");
+
+   mask->ret_mask = LLVMBuildAnd(mask->bld->builder,
+                                 mask->ret_mask,
+                                 exec_mask, "ret_full");
+
+   lp_exec_mask_update(mask);
+}
+
+
 static void lp_exec_continue(struct lp_exec_mask *mask)
 {
    LLVMValueRef exec_mask = LLVMBuildNot(mask->bld->builder,
@@ -368,6 +568,136 @@ static void lp_exec_mask_store(struct lp_exec_mask *mask,
       LLVMBuildStore(mask->bld->builder, val, dst);
 }
 
+static LLVMValueRef
+emit_vec_alloca_array(struct lp_build_tgsi_soa_context *bld,
+                      LLVMTypeRef vec_type,
+                      int size)
+{
+   LLVMValueRef val = LLVMConstInt(LLVMInt32Type(),
+                                   size * 4 + 4, 0);
+   return lp_build_array_alloca(bld->base.builder,
+                                vec_type, val, "");
+}
+
+static void
+emit_preamble(struct lp_build_tgsi_soa_context *bld, uint num_immediates)
+{
+   LLVMTypeRef vec_type = lp_build_vec_type(bld->base.type);
+
+   /* temps */
+   if (bld->has_indirect_addressing ||
+       bld->has_function_calls) {
+      int size = bld->full_range.temps.Last + 1;
+      bld->temps_array = emit_vec_alloca_array(bld, vec_type, size);
+   }
+   if (bld->has_function_calls) {
+      int i;
+      int size = bld->full_range.outputs.Last + 1;
+      bld->outputs_array  = emit_vec_alloca_array(bld, vec_type, size);
+
+      /* we need to insert the created immediates into our array */
+      size = num_immediates;
+      if (size > 0)
+         bld->immediates_array  = emit_vec_alloca_array(bld, vec_type, size);
+      for (i = 0; i < size; ++i) {
+         int j;
+         for (j = 0; j < NUM_CHANNELS; ++j) {
+            LLVMValueRef ptr = get_immediates_ptr(bld,
+                                                  i, j,
+                                                  FALSE, 0);
+            LLVMBuildStore(bld->base.builder,
+                           bld->immediates[i][j],
+                           ptr);
+         }
+      }
+
+      size = bld->full_range.addrs.Last + 1;
+      bld->addrs_array  = emit_vec_alloca_array(bld, vec_type, size);
+
+      size = bld->full_range.preds.Last + 1;
+      bld->preds_array  = emit_vec_alloca_array(bld, vec_type, size);
+
+      /*inputs also need to be copied*/
+      size = bld->full_range.inputs.Last + 1;
+      bld->inputs_array  = emit_vec_alloca_array(bld, vec_type, size);
+      for (i = bld->full_range.inputs.First; i < size; ++i) {
+         int j;
+         for (j = 0; j < NUM_CHANNELS; ++j) {
+            LLVMValueRef ptr = get_input_ptr(bld,
+                                             i, j,
+                                             FALSE, 0);
+            LLVMBuildStore(bld->base.builder,
+                           bld->inputs[i][j],
+                           ptr);
+         }
+      }
+   }
+}
+
+static void
+emit_end(struct lp_build_tgsi_soa_context *bld)
+{
+   int i, j;
+
+   bld->main_block = LLVMGetInsertBlock(bld->base.builder);
+
+   /* if we had function calls we want to propagate the
+    * outputs from the array to the values */
+   if (bld->has_function_calls) {
+      int size = bld->full_range.outputs.Last + 1;
+      for (i = bld->full_range.outputs.First; i < size; ++i) {
+         for (j = 0; j < NUM_CHANNELS; ++j) {
+            LLVMValueRef ptr = get_output_ptr(bld, i, j,
+                                              FALSE, 0);
+            bld->outputs[i][j] = ptr;
+         }
+      }
+   }
+}
+
+static void
+emit_bgnsub(struct lp_build_tgsi_soa_context *bld)
+{
+   LLVMValueRef func = lp_get_function(bld, bld->instno);
+   LLVMBasicBlockRef block;
+   LLVMValueRef inputs_ptr, outputs_ptr,
+      consts_ptr, temps_ptr, addrs_ptr, preds_ptr, imms_ptr;
+
+   inputs_ptr  = LLVMGetParam(func, 0);
+   outputs_ptr  = LLVMGetParam(func, 1);
+   consts_ptr  = LLVMGetParam(func, 2);
+   temps_ptr  = LLVMGetParam(func, 3);
+   addrs_ptr  = LLVMGetParam(func, 4);
+   preds_ptr  = LLVMGetParam(func, 5);
+   imms_ptr  = LLVMGetParam(func, 6);
+
+   lp_build_name(inputs_ptr, "inputs");
+   lp_build_name(outputs_ptr, "outputs");
+   lp_build_name(consts_ptr, "consts");
+   lp_build_name(temps_ptr, "temps");
+   lp_build_name(addrs_ptr, "addrs");
+   lp_build_name(preds_ptr, "preds");
+   lp_build_name(imms_ptr, "immediates");
+
+   bld->inputs_array = inputs_ptr;
+   bld->outputs_array = outputs_ptr;
+   bld->consts_ptr = consts_ptr;
+   bld->temps_array = temps_ptr;
+   bld->addrs_array = addrs_ptr;
+   bld->preds_array = preds_ptr;
+   bld->immediates_array = imms_ptr;
+
+   block = LLVMAppendBasicBlock(func, "entry");
+   LLVMPositionBuilderAtEnd(bld->base.builder, block);
+
+   lp_exec_bgnsub(&bld->exec_mask);
+}
+
+static void
+emit_endsub(struct lp_build_tgsi_soa_context *bld)
+{
+   LLVMBuildRetVoid(bld->base.builder);
+}
 
 static LLVMValueRef
 emit_ddx(struct lp_build_tgsi_soa_context *bld,
@@ -388,25 +718,6 @@ emit_ddy(struct lp_build_tgsi_soa_context *bld,
    return lp_build_sub(&bld->base, src_top, src_bottom);
 }
 
-static LLVMValueRef
-get_temp_ptr(struct lp_build_tgsi_soa_context *bld,
-             unsigned index,
-             unsigned chan,
-             boolean is_indirect,
-             LLVMValueRef addr)
-{
-   assert(chan < 4);
-   if (!bld->has_indirect_addressing) {
-      return bld->temps[index][chan];
-   } else {
-      LLVMValueRef lindex =
-         LLVMConstInt(LLVMInt32Type(), index * 4 + chan, 0);
-      if (is_indirect)
-         lindex = lp_build_add(&bld->base, lindex, addr);
-      return LLVMBuildGEP(bld->base.builder, bld->temps_array, &lindex, 1, "");
-   }
-}
-
 /**
  * Register fetch.
  */
@@ -432,7 +743,7 @@ emit_fetch(
       LLVMTypeRef int_vec_type = lp_build_int_vec_type(bld->base.type);
       unsigned swizzle = tgsi_util_get_src_register_swizzle( &reg->Indirect, chan_index );
       addr = LLVMBuildLoad(bld->base.builder,
-                           bld->addr[reg->Indirect.Index][swizzle],
+                           get_addr_ptr(bld, reg->Indirect.Index, swizzle, FALSE, 0),
                            "");
       /* for indexing we want integers */
       addr = LLVMBuildFPToSI(bld->base.builder, addr,
@@ -464,12 +775,26 @@ emit_fetch(
       break;
 
    case TGSI_FILE_IMMEDIATE:
-      res = bld->immediates[reg->Register.Index][swizzle];
+      if (bld->has_function_calls) {
+         LLVMValueRef ptr = get_immediates_ptr(bld,
+                                               reg->Register.Index,
+                                               swizzle,
+                                               FALSE, 0);
+         res = LLVMBuildLoad(bld->base.builder, ptr, "");
+      } else
+         res = bld->immediates[reg->Register.Index][swizzle];
       assert(res);
       break;
 
    case TGSI_FILE_INPUT:
-      res = bld->inputs[reg->Register.Index][swizzle];
+      if (bld->has_function_calls) {
+         LLVMValueRef ptr = get_input_ptr(bld,
+                                          reg->Register.Index,
+                                          swizzle,
+                                          FALSE, 0);
+         res = LLVMBuildLoad(bld->base.builder, ptr, "");
+      } else
+         res = bld->inputs[reg->Register.Index][swizzle];
       assert(res);
       break;
 
@@ -581,8 +906,10 @@ emit_fetch_predicate(
        * in the swizzles
        */
       if (!unswizzled[swizzle]) {
+         LLVMValueRef pred_ptr = get_preds_ptr(bld, index, swizzle,
+                                               FALSE, 0);
          value = LLVMBuildLoad(bld->base.builder,
-                               bld->preds[index][swizzle], "");
+                               pred_ptr, "");
 
          /*
           * Convert the value to an integer mask.
@@ -647,7 +974,7 @@ emit_store(
       LLVMTypeRef int_vec_type = lp_build_int_vec_type(bld->base.type);
       unsigned swizzle = tgsi_util_get_src_register_swizzle( &reg->Indirect, chan_index );
       addr = LLVMBuildLoad(bld->base.builder,
-                           bld->addr[reg->Indirect.Index][swizzle],
+                           get_addr_ptr(bld, reg->Indirect.Index, swizzle, FALSE, 0),
                            "");
       /* for indexing we want integers */
       addr = LLVMBuildFPToSI(bld->base.builder, addr,
@@ -661,7 +988,8 @@ emit_store(
    switch( reg->Register.File ) {
    case TGSI_FILE_OUTPUT:
       lp_exec_mask_store(&bld->exec_mask, pred, value,
-                         bld->outputs[reg->Register.Index][chan_index]);
+                         get_output_ptr(bld, reg->Register.Index, chan_index,
+                                        FALSE, 0));
       break;
 
    case TGSI_FILE_TEMPORARY: {
@@ -675,12 +1003,14 @@ emit_store(
 
    case TGSI_FILE_ADDRESS:
       lp_exec_mask_store(&bld->exec_mask, pred, value,
-                         bld->addr[reg->Indirect.Index][chan_index]);
+                         get_addr_ptr(bld, reg->Indirect.Index, chan_index,
+                                      FALSE, 0));
       break;
 
    case TGSI_FILE_PREDICATE:
       lp_exec_mask_store(&bld->exec_mask, pred, value,
-                         bld->preds[index][chan_index]);
+                         get_preds_ptr(bld, index, chan_index,
+                                       FALSE, 0));
       break;
 
    default:
@@ -875,6 +1205,14 @@ emit_kilp(struct lp_build_tgsi_soa_context *bld,
 }
 
 static void
+range_check(struct tgsi_declaration_range *range,
+            unsigned new_first, unsigned new_last)
+{
+   range->First = MIN2(range->First, new_first);
+   range->Last = MAX2(range->Last, new_last);
+}
+
+static void
 emit_declaration(
    struct lp_build_tgsi_soa_context *bld,
    const struct tgsi_full_declaration *decl)
@@ -889,12 +1227,10 @@ emit_declaration(
       switch (decl->Declaration.File) {
       case TGSI_FILE_TEMPORARY:
          assert(idx < LP_MAX_TGSI_TEMPS);
-         if (bld->has_indirect_addressing) {
-            LLVMValueRef val = LLVMConstInt(LLVMInt32Type(),
-                                            last*4 + 4, 0);
-            bld->temps_array = lp_build_array_alloca(bld->base.builder,
-                                                     vec_type, val, "");
-         } else {
+         range_check(&bld->full_range.temps,
+                     first, last);
+         if (!bld->has_indirect_addressing &&
+             !bld->has_function_calls) {
             for (i = 0; i < NUM_CHANNELS; i++)
                bld->temps[idx][i] = lp_build_alloca(bld->base.builder,
                                                     vec_type, "");
@@ -902,23 +1238,40 @@ emit_declaration(
          break;
 
       case TGSI_FILE_OUTPUT:
-         for (i = 0; i < NUM_CHANNELS; i++)
-            bld->outputs[idx][i] = lp_build_alloca(bld->base.builder,
-                                                   vec_type, "");
+         range_check(&bld->full_range.outputs,
+                     first, last);
+         if (!bld->has_function_calls) {
+            for (i = 0; i < NUM_CHANNELS; i++)
+               bld->outputs[idx][i] = lp_build_alloca(bld->base.builder,
+                                                      vec_type, "");
+         }
          break;
 
       case TGSI_FILE_ADDRESS:
          assert(idx < LP_MAX_TGSI_ADDRS);
-         for (i = 0; i < NUM_CHANNELS; i++)
-            bld->addr[idx][i] = lp_build_alloca(bld->base.builder,
-                                                vec_type, "");
+         range_check(&bld->full_range.addrs,
+                     first, last);
+         if (!bld->has_function_calls) {
+            for (i = 0; i < NUM_CHANNELS; i++)
+               bld->addr[idx][i] = lp_build_alloca(bld->base.builder,
+                                                   vec_type, "");
+         }
          break;
 
       case TGSI_FILE_PREDICATE:
          assert(idx < LP_MAX_TGSI_PREDS);
-         for (i = 0; i < NUM_CHANNELS; i++)
-            bld->preds[idx][i] = lp_build_alloca(bld->base.builder,
-                                                 vec_type, "");
+         range_check(&bld->full_range.preds,
+                     first, last);
+         if (!bld->has_function_calls) {
+            for (i = 0; i < NUM_CHANNELS; i++)
+               bld->preds[idx][i] = lp_build_alloca(bld->base.builder,
+                                                    vec_type, "");
+         }
+         break;
+
+      case TGSI_FILE_INPUT:
+         range_check(&bld->full_range.inputs,
+                     first, last);
          break;
 
       default:
@@ -1558,17 +1911,26 @@ emit_instruction(
       return FALSE;
       break;
 
-   case TGSI_OPCODE_CAL:
-      /* FIXME */
-      return FALSE;
+   case TGSI_OPCODE_CAL: {
+      LLVMValueRef args[7];
+      LLVMValueRef func = lp_get_function(bld, inst->Label.Label);
+      args[0] = bld->inputs_array;
+      args[1] = bld->outputs_array;
+      args[2] = bld->consts_ptr;
+      args[3] = bld->temps_array;
+      args[4] = bld->addrs_array;
+      args[5] = bld->preds_array;
+      args[6] = bld->immediates_array;
+      LLVMBuildCall(bld->base.builder, func, args, Elements(args), "");
+   }
       break;
 
    case TGSI_OPCODE_RET:
-      /* FIXME */
-      return FALSE;
+      lp_exec_ret(&bld->exec_mask);
       break;
 
    case TGSI_OPCODE_END:
+      emit_end(bld);
       break;
 
    case TGSI_OPCODE_SSG:
@@ -1734,6 +2096,10 @@ emit_instruction(
       lp_exec_bgnloop(&bld->exec_mask);
       break;
 
+   case TGSI_OPCODE_BGNSUB:
+      emit_bgnsub(bld);
+      break;
+
    case TGSI_OPCODE_ELSE:
       lp_exec_mask_cond_invert(&bld->exec_mask);
       break;
@@ -1746,6 +2112,10 @@ emit_instruction(
       lp_exec_endloop(&bld->exec_mask);
       break;
 
+   case TGSI_OPCODE_ENDSUB:
+      emit_endsub(bld);
+      break;
+
    case TGSI_OPCODE_PUSHA:
       /* deprecated? */
       assert(0);
@@ -1900,6 +2270,8 @@ lp_build_tgsi_soa(LLVMBuilderRef builder,
    bld.sampler = sampler;
    bld.has_indirect_addressing = info->opcode_count[TGSI_OPCODE_ARR] > 0 ||
                                  info->opcode_count[TGSI_OPCODE_ARL] > 0;
+   bld.has_function_calls = info->opcode_count[TGSI_OPCODE_CAL] > 0;
+   bld.func_hash = cso_hash_create();
 
    lp_exec_mask_init(&bld.exec_mask, &bld.base);
 
@@ -1918,9 +2290,15 @@ lp_build_tgsi_soa(LLVMBuilderRef builder,
          {
             unsigned opcode = parse.FullToken.FullInstruction.Instruction.Opcode;
             const struct tgsi_opcode_info *opcode_info = tgsi_get_opcode_info(opcode);
+            /* we finished processing declarations, emit anything that needs
+             * to go before the first instruction */
+            if (bld.instno == 0) {
+               emit_preamble(&bld, num_immediates);
+            }
             if (!emit_instruction( &bld, &parse.FullToken.FullInstruction, opcode_info ))
                _debug_printf("warning: failed to translate tgsi opcode %s to LLVM\n",
                              opcode_info->mnemonic);
+            bld.instno++;
          }
 
          break;
@@ -1947,14 +2325,20 @@ lp_build_tgsi_soa(LLVMBuilderRef builder,
          assert( 0 );
       }
    }
+   /* we have to make sure we're at the end of the main block
+    * (which won't be the case if we had more than one TGSI function
+    * in the given shader) to let the calling function append
+    * whatever it needs at the end of the main function */
+   LLVMPositionBuilderAtEnd(bld.base.builder, bld.main_block);
+
    if (0) {
       LLVMBasicBlockRef block = LLVMGetInsertBlock(builder);
       LLVMValueRef function = LLVMGetBasicBlockParent(block);
-      debug_printf("11111111111111111111111111111 \n");
       tgsi_dump(tokens, 0);
       lp_debug_dump_value(function);
-      debug_printf("2222222222222222222222222222 \n");
    }
    tgsi_parse_free( &parse );
+
+   cso_hash_delete(bld.func_hash);
 }