remove debugscont4

6 files changed, 129 insertions, 126 deletions

diff --git a/src/mesa/drivers/dri/i965/brw_program.c b/src/mesa/drivers/dri/i965/brw_program.c
index cfad716038..e30c422828 100644
--- a/src/mesa/drivers/dri/i965/brw_program.c
+++ b/src/mesa/drivers/dri/i965/brw_program.c
@@ -461,10 +461,10 @@ brwUniformStorageChange(struct gl_context *ctx, struct gl_shader_program *prog,
    /* Update the gather table to reflect the new offsets */
    struct brw_gather_table *gt = shader_prog->storage_table[loc].gather_table;
 
-   printf("    =Offset: %d | livearr: %d | Total elements: %d\n",
-          shader_prog->storage_table[loc].offset,
-          shader_prog->storage_table[loc].live_array_nr,
-          shader_prog->storage_table[loc].elements);
+   /* printf("    =Offset: %d | livearr: %d | Total elements: %d\n", */
+   /*        shader_prog->storage_table[loc].offset, */
+   /*        shader_prog->storage_table[loc].live_array_nr, */
+   /*        shader_prog->storage_table[loc].elements); */
 
    /** Update active entries in the gather table. If the uniform
     *  storage is an array, the gather table might have been repacked. Only
@@ -480,9 +480,9 @@ brwUniformStorageChange(struct gl_context *ctx, struct gl_shader_program *prog,
       gt[gather_idx].const_offset =
          shader_prog->storage_table[loc].offset + (base_size * array_idx);
       max_array_index = MAX2(max_array_index, array_idx);
-      printf("      Update GT[%d]| new offset: %d | base: %d, Array index: %d | max: %d\n",
-             gather_idx,
-             gt[gather_idx].const_offset, base_size, array_idx, max_array_index);
+      /* printf("      Update GT[%d]| new offset: %d | base: %d, Array index: %d | max: %d\n", */
+      /*        gather_idx, */
+      /*        gt[gather_idx].const_offset, base_size, array_idx, max_array_index); */
    }
 
 //printf(" sz: %d\n", max_array_index);
diff --git a/src/mesa/drivers/dri/i965/brw_shader.cpp b/src/mesa/drivers/dri/i965/brw_shader.cpp
index 0be454e74b..361148a613 100644
--- a/src/mesa/drivers/dri/i965/brw_shader.cpp
+++ b/src/mesa/drivers/dri/i965/brw_shader.cpp
@@ -442,14 +442,14 @@ void brw_associate_uniform_storage(struct gl_context *ctx,
 
       prog->reset_update_flags[prog->nr_updates++] =
          &prog->storage_table[loc].needs_update;
-      printf(" Attach Storage size: %d [loc:%d] "
-             "dmul: %d cols: %d | rows: %d array elements: %d | off:%d | elements: %d |"
-             "components: %d\n", 
-             size, loc, dmul, columns, rows, MAX2(storage->array_elements, 1),
-             prog->storage_table[loc].offset,
-             prog->storage_table[loc].elements,
-             storage->type->component_slots()
-         );
+      // printf(" Attach Storage size: %d [loc:%d] "
+      //        "dmul: %d cols: %d | rows: %d array elements: %d | off:%d | elements: %d |"
+      //        "components: %d\n", 
+      //        size, loc, dmul, columns, rows, MAX2(storage->array_elements, 1),
+      //        prog->storage_table[loc].offset,
+      //        prog->storage_table[loc].elements,
+      //        storage->type->component_slots()
+      //    );
     }
 }
 
diff --git a/src/mesa/drivers/dri/i965/brw_vec4.cpp b/src/mesa/drivers/dri/i965/brw_vec4.cpp
index 933fc729b0..61761699a4 100644
--- a/src/mesa/drivers/dri/i965/brw_vec4.cpp
+++ b/src/mesa/drivers/dri/i965/brw_vec4.cpp
@@ -554,11 +554,11 @@ vec4_visitor::pack_uniform_registers()
 
       if (!uniform_used[src]) {
 	 this->uniform_vector_size[src] = 0;
-         printf("  ==- SKIP out [%d]\n", src);
+         //printf("  ==- SKIP out [%d]\n", src);
 	 continue;
       }
       
-      printf("+ ADD Uni << %d >> size: %d\n", src, size);
+      //printf("+ ADD Uni << %d >> size: %d\n", src, size);
       int dst;
       /* Find the lowest place we can slot this uniform in. However, when
        * our constants come from a mix of UBO and uniform sources, don't allow registers
@@ -585,8 +585,8 @@ vec4_visitor::pack_uniform_registers()
             for (int j = 0; j < size; j++) {
                int dest_pos = dst * 4 + new_chan[src] + j;
                int src_pos = src * 4 + j;
-               printf("   -- Packing To param[%d] from param[%d] | (uniform) dst: %d src: %d\n",
-                      dest_pos, src_pos, dst, src);
+               // printf("   -- Packing To param[%d] from param[%d] | (uniform) dst: %d src: %d\n",
+               //        dest_pos, src_pos, dst, src);
                stage_prog_data->param[dest_pos] =
                   stage_prog_data->param[src_pos];
             }
@@ -611,13 +611,13 @@ vec4_visitor::pack_uniform_registers()
 	 if (inst->src[i].file != UNIFORM)
 	    continue;
 
-         printf("   Repack reg g%d --> g%d swiz[%d,%d,%d,%d] ",
-                inst->src[i].reg, new_loc[src], new_chan[src], new_chan[src],
-                new_chan[src], new_chan[src]);
+         // printf("   Repack reg g%d --> g%d swiz[%d,%d,%d,%d] ",
+         //        inst->src[i].reg, new_loc[src], new_chan[src], new_chan[src],
+         //        new_chan[src], new_chan[src]);
 	 inst->src[i].reg = new_loc[src];
          inst->src[i].swizzle += BRW_SWIZZLE4(new_chan[src], new_chan[src],
                                               new_chan[src], new_chan[src]);
-         printf("swiz: 0x%x\n", inst->src[i].swizzle);
+         // printf("swiz: 0x%x\n", inst->src[i].swizzle);
       }
    }
 #define CONT   
@@ -654,7 +654,7 @@ vec4_visitor::pack_uniform_registers()
    for (unsigned i = 0; i < this->nr_gather_table; i++) {
       int uni_position = this->ubo_gather_table[i].reg;
       if (!uniform_used[uni_position]) {
-         printf("  GT %d skip out %d\n", i, uni_position);
+         // printf("  GT %d skip out %d\n", i, uni_position);
          continue;
       }
 
@@ -665,7 +665,7 @@ vec4_visitor::pack_uniform_registers()
 
       int loc = this->ubo_gather_table[i].uniform_location;
       if (loc == -1) {
-         printf("  GT %d skip out %d\n", i);
+         // printf("  GT %d skip out %d\n", i);
          continue;
       }
 
@@ -688,14 +688,14 @@ vec4_visitor::pack_uniform_registers()
                                   .live_array_indices[arr_idx].array_index);
       prog->storage_table[loc].live_size = prog->storage_table[loc].base_size *
          (max_array_index[loc] + 1);
-      printf("  Generate GT[%d] from gt[%d] | comps: %d |mask :0x%x |"
-             "new_loc: %d | arr_idx: %d | offs: %d\n",
-             gather_index, uni_position, this->ubo_gather_table[i].components,
-             this->ubo_gather_table[i].channel_mask,
-             (gather_index == new_loc[uni_position] ? gather_index :
-              (new_loc[uni_position] + 1), arr_idx),
-             this->ubo_gather_table[i].const_offset
-         );
+      // printf("  Generate GT[%d] from gt[%d] | comps: %d |mask :0x%x |"
+      //        "new_loc: %d | arr_idx: %d | offs: %d\n",
+      //        gather_index, uni_position, this->ubo_gather_table[i].components,
+      //        this->ubo_gather_table[i].channel_mask,
+      //        (gather_index == new_loc[uni_position] ? gather_index :
+      //         (new_loc[uni_position] + 1), arr_idx),
+      //        this->ubo_gather_table[i].const_offset
+      //    );
    }
 
    stage_prog_data->program = prog;
@@ -721,7 +721,7 @@ vec4_visitor::pack_uniform_registers()
       reindexed_location[uni_position] = false;
       
       if (i == new_loc[uni_position]) {
-         printf(" [Skipping %d]\n", i);
+         // printf(" [Skipping %d]\n", i);
          continue;
       }
 
@@ -738,11 +738,11 @@ vec4_visitor::pack_uniform_registers()
       /* Update the packed uniform's position within the gather table */
       int unpacked_gather_index = gather_index_loc[uni_position];
 
-      printf("  Tst Uniform reg: %d(%d) new_loc: %d | Cur pcked GTidx: %d | "
-             "unpcked GT idx: %d target_idx: %d | Sz: %d\n",
-             uni_position, i, nloc, gather_index_loc[nloc],
-             unpacked_gather_index, target_idx,
-             this->uniform_vector_size[nloc]);
+      // printf("  Tst Uniform reg: %d(%d) new_loc: %d | Cur pcked GTidx: %d | "
+      //        "unpcked GT idx: %d target_idx: %d | Sz: %d\n",
+      //        uni_position, i, nloc, gather_index_loc[nloc],
+      //        unpacked_gather_index, target_idx,
+      //        this->uniform_vector_size[nloc]);
 
       gather_index_loc[nloc] = unpacked_gather_index;
 
@@ -755,15 +755,15 @@ vec4_visitor::pack_uniform_registers()
       // }
       //  gather_index_loc[uni_position] = nloc;
       // Update the uniform location
-      printf("    ... change reg: %d => %d | Target %d Cur idx?: %d\n",
-             stage_prog_data->gather_table[i].reg, nloc, target_idx,
-             current_index);
+      // printf("    ... change reg: %d => %d | Target %d Cur idx?: %d\n",
+      //        stage_prog_data->gather_table[i].reg, nloc, target_idx,
+      //        current_index);
       stage_prog_data->gather_table[i].reg = nloc;
 
 
       if (i == target_idx || i == current_index) {
          // stage_prog_data->gather_table[i].channel_mask = 0xf;
-         printf(" [Skipping %d]\n", i);
+         // printf(" [Skipping %d]\n", i);
          continue;
       }
       current_index++;
@@ -772,12 +772,12 @@ vec4_visitor::pack_uniform_registers()
        * step forward to make space for the re-indexed entry.
        */
       struct brw_gather_table re_index = stage_prog_data->gather_table[i];
-      printf(" ==>  Target index %d: GT[%d] (data_mask: 0x%x) sz: %d IDx GT: %d "
-             "Updated target? %s\n",
-             target_idx, i, re_index.channel_mask,
-             this->uniform_vector_size[uni_position],
-             gather_index_loc[uni_position],
-             reindexed_location[target_idx] ? "True":"False");
+      // printf(" ==>  Target index %d: GT[%d] (data_mask: 0x%x) sz: %d IDx GT: %d "
+      //        "Updated target? %s\n",
+      //        target_idx, i, re_index.channel_mask,
+      //        this->uniform_vector_size[uni_position],
+      //        gather_index_loc[uni_position],
+      //        reindexed_location[target_idx] ? "True":"False");
       int src_idx = i - 1;
       if (target_idx != src_idx) {
          for (; src_idx >= target_idx; src_idx--) {
@@ -785,8 +785,8 @@ vec4_visitor::pack_uniform_registers()
                .uniform_location;
             int new_gather_idx = src_idx + 1;
          
-            printf(" i: %d, New index: %d newgt: %d, src_id: %d\n", i,
-                   target_idx, new_gather_idx, src_idx);
+            // printf(" i: %d, New index: %d newgt: %d, src_id: %d\n", i,
+            // target_idx, new_gather_idx, src_idx);
             // if (target_idx == src_idx)
             //    break;
 
@@ -797,10 +797,10 @@ vec4_visitor::pack_uniform_registers()
 
             reindexed_location[src_idx] = true;
          
-            printf("   Moving GT: %d <-- (*Updated) %d gt idx: %d sz: %d\n", 
-                   new_gather_idx, src_idx, prog->storage_table[src_uni_loc]
-                   .live_array_indices[0].gather_index,
-                   this->uniform_vector_size[src_uni_loc]);
+            // printf("   Moving GT: %d <-- (*Updated) %d gt idx: %d sz: %d\n", 
+            //        new_gather_idx, src_idx, prog->storage_table[src_uni_loc]
+            //        .live_array_indices[0].gather_index,
+            //        this->uniform_vector_size[src_uni_loc]);
 
             // Find and update the gather index within the array that
             // has been changed
@@ -808,12 +808,12 @@ vec4_visitor::pack_uniform_registers()
                prog->storage_table[src_uni_loc];
             for (int p = 0; p < prog->storage_table[src_uni_loc].live_array_nr;
                  p++) {
-               printf("   ??? gt idx: %d\n", storage_data
-                      .live_array_indices[p].gather_index);
+               // printf("   ??? gt idx: %d\n", storage_data
+               //        .live_array_indices[p].gather_index);
                if (storage_data.live_array_indices[p].gather_index == src_idx) {
-                  printf("             ->Got idx: %d\n",
+                  // printf("             ->Got idx: %d\n",
 
-                         storage_data.live_array_indices[p].gather_index);
+                  //        storage_data.live_array_indices[p].gather_index);
                   storage_data.live_array_indices[p].gather_index = new_gather_idx;
                }               
             }
@@ -823,8 +823,8 @@ vec4_visitor::pack_uniform_registers()
       if (reindexed_location[target_idx]) {
          const int old_index = prog->storage_table[re_index.uniform_location]
             .live_array_indices[0].gather_index;
-         printf("    ->Moving GT: %d <-- (*Updated) %d | data (mask): 0x%x | i: %d\n",
-                target_idx, i, re_index.channel_mask, i);
+         // printf("    ->Moving GT: %d <-- (*Updated) %d | data (mask): 0x%x | i: %d\n",
+         //        target_idx, i, re_index.channel_mask, i);
 
          prog->storage_table[re_index.uniform_location]
             .live_array_indices[0].gather_index = target_idx;
@@ -834,9 +834,12 @@ vec4_visitor::pack_uniform_registers()
       }
    }
 #if 1
+   if (stage_prog_data->nr_gather_table <= 0)
+      return;
+
    // Make sure that each register fetch is aligned to 16-bytes.
    // Modify the channel mask to add padding zeroes if necessary.
-   printf("\n\n");
+   // printf("\n\n");
    for (int i = 0; i < stage_prog_data->nr_gather_table - 1; i++) {
       // if (!reindexed_location[i])
       //    continue;
@@ -847,7 +850,7 @@ vec4_visitor::pack_uniform_registers()
       int current_count = _mesa_fls(current.channel_mask);
 
 
-      printf(" (%d) Count : %d\n", i, current_count);
+      // printf(" (%d) Count : %d\n", i, current_count);
 
       /* Make sure that the subsequent fetch fit in 16-bytes */
       bool skip_entry = false;
@@ -859,12 +862,12 @@ vec4_visitor::pack_uniform_registers()
          next_count =
             _mesa_fls(stage_prog_data->gather_table[n].channel_mask);
          int combined = total_count + next_count;
-         printf("     next idx: %d count: %d | Potential "
-                "combined: %d\n",
-                n, next_count, combined);
+         // printf("     next idx: %d count: %d | Potential "
+         //        "combined: %d\n",
+         //        n, next_count, combined);
          if (combined == 4) {
             // Fits nicely within 16-bytes
-            printf("        PERFECT fit this, Current to 0xF\n");
+            // printf("        PERFECT fit this, Current to 0xF\n");
             skip_entry = true;
             i = n;
             break;
@@ -872,7 +875,7 @@ vec4_visitor::pack_uniform_registers()
             total_count += next_count;
             next_index = n;
             pad_next_entry = true;
-            printf("           --> TOTAL: %d\n", total_count);
+            // printf("           --> TOTAL: %d\n", total_count);
          }
          
          if (total_count > 4) {
@@ -883,15 +886,15 @@ vec4_visitor::pack_uniform_registers()
       if (skip_entry)
          continue;
 
-      printf(" NExt INDEX: %d\n", next_index);
+      // printf(" NExt INDEX: %d\n", next_index);
       struct brw_gather_table& next = stage_prog_data->gather_table[next_index];
       
       if (pad_next_entry) {
          unsigned mask = ((2 << (4 - current_count)) - 1) >> 1;
-         printf("  ++<< Setting Next Entry (i:%d)  next: %d  current count: %d "
-                "next count: %d | mask 0x%x | total: %d>>\n",
-                i, next_index, current_count, next_count,
-                mask, total_count);
+         // printf("  ++<< Setting Next Entry (i:%d)  next: %d  current count: %d "
+         //        "next count: %d | mask 0x%x | total: %d>>\n",
+         //        i, next_index, current_count, next_count,
+         //        mask, total_count);
          next.channel_mask = mask;
 
 
@@ -900,13 +903,13 @@ vec4_visitor::pack_uniform_registers()
       }
       
       // if (pad_current_entry) {
-         printf("   PADD current entry, Current to 0xF\n");
+         // printf("   PADD current entry, Current to 0xF\n");
          current.channel_mask = 0xf;
          //  }
 
-      printf("   [Skipping i:%d  next: %d  Table size: %d totalcount: %d]\n",
-             i, next_index,
-             stage_prog_data->nr_gather_table, total_count);
+      // printf("   [Skipping i:%d  next: %d  Table size: %d totalcount: %d]\n",
+      //        i, next_index,
+      //        stage_prog_data->nr_gather_table, total_count);
 
       // if (current_count + next_count <= 4) {
       //    int next_idx = i++;
@@ -923,8 +926,8 @@ vec4_visitor::pack_uniform_registers()
    }
 #endif
 
-   for (int i = 0; i < stage_prog_data->nr_gather_table; i++)
-      printf(" GT[%d].0x%x\n", i, stage_prog_data->gather_table[i].channel_mask);
+   // for (int i = 0; i < stage_prog_data->nr_gather_table; i++)
+   //    printf(" GT[%d].0x%x\n", i, stage_prog_data->gather_table[i].channel_mask);
 
 #endif
    
diff --git a/src/mesa/drivers/dri/i965/brw_vec4_nir.cpp b/src/mesa/drivers/dri/i965/brw_vec4_nir.cpp
index dda5cee6f9..1870219c06 100644
--- a/src/mesa/drivers/dri/i965/brw_vec4_nir.cpp
+++ b/src/mesa/drivers/dri/i965/brw_vec4_nir.cpp
@@ -234,30 +234,30 @@ vec4_visitor::nir_setup_uniform(nir_variable *var)
        gl_constant_value *components = storage->storage;
        unsigned vector_count = (MAX2(storage->array_elements, 1) *
                                 storage->type->matrix_columns);
-       printf("Add vec4 uniforms: count: %d\n", vector_count);
+       //printf("Add vec4 uniforms: count: %d\n", vector_count);
        int uniform_start = uniforms;
        for (unsigned s = 0; s < vector_count; s++) {
           assert(uniforms < uniform_array_size);
           uniform_vector_size[uniforms] = storage->type->vector_elements;
 
-          printf("  +UNI[%d] size: %d | comps: %d | arrs: %d\n",
-                 uniforms, uniform_vector_size[uniforms],
-                 storage->type->component_slots(),
-                 storage->array_elements);
+          // printf("  +UNI[%d] size: %d | comps: %d | arrs: %d\n",
+          //        uniforms, uniform_vector_size[uniforms],
+          //        storage->type->component_slots(),
+          //        storage->array_elements);
           int i;
           for (i = 0; i < uniform_vector_size[uniforms]; i++) {
              int idx = uniforms * 4 + i;
              stage_prog_data->param[idx] = components;
-             printf("     i:%d uni:%d p[%d] loc: %d | s: %d\n", i, 
-                    uniforms, idx, loc, s);
+             // printf("     i:%d uni:%d p[%d] loc: %d | s: %d\n", i, 
+             //        uniforms, idx, loc, s);
              components++;
           }
           for (; i < 4; i++) {
              static const gl_constant_value zero = { 0.0 };
              int idx = uniforms * 4 + i;
              stage_prog_data->param[idx] = &zero;
-             printf("     i:%d uni:%d p[%d] = ZERO loc: %d\n", i, 
-                    uniforms, idx, loc);
+             // printf("     i:%d uni:%d p[%d] = ZERO loc: %d\n", i, 
+             //        uniforms, idx, loc);
           }
 
 #if 1
@@ -271,7 +271,7 @@ vec4_visitor::nir_setup_uniform(nir_variable *var)
           this->ubo_gather_table[p].uniform_location = loc;
 
           if (s == 0) {
-             printf("  Base index: %d\n", p);
+             // printf("  Base index: %d\n", p);
              prog->storage_table[loc].base_index = p;
           }
 #endif
@@ -284,7 +284,7 @@ vec4_visitor::nir_setup_uniform(nir_variable *var)
           (MAX2(storage->type->component_slots(), 1) /
            storage->type->matrix_columns) : 1;
        int cond = storage->type->is_matrix() ? rows : vector_count;
-       printf("= Slots: %d= condition: %d\n", rows, cond);
+       // printf("= Slots: %d= condition: %d\n", rows, cond);
        int base_elements = storage->type->is_matrix() ?
           storage->type->matrix_columns : uniform_vector_size[uniform_start];
        for (int n = 0; n < cond; n++) {        
@@ -299,11 +299,11 @@ vec4_visitor::nir_setup_uniform(nir_variable *var)
           this->ubo_gather_table[p].uniform_location = loc;
 
           if (n == 0) {
-             printf("  Base index: %d\n", p);
+             // printf("  Base index: %d\n", p);
              prog->storage_table[loc].base_index = p;
           }
-          printf(" Add GT: %d, mask: 0x%x | elements: %d \n",p,
-                 this->ubo_gather_table[p].channel_mask, base_elements);
+          // printf(" Add GT: %d, mask: 0x%x | elements: %d \n",p,
+          //        this->ubo_gather_table[p].channel_mask, base_elements);
        }
 #endif
 #endif
@@ -642,8 +642,8 @@ vec4_visitor::nir_emit_intrinsic(nir_intrinsic_instr *instr)
       }
 
       emit(MOV(dest, src));
-      printf(" Gen uni reg: mov g%d.%d  g%d.%d\n", 
-             dest.reg, dest.reg_offset, src.reg, src.reg_offset);
+      // printf(" Gen uni reg: mov g%d.%d  g%d.%d\n", 
+      //        dest.reg, dest.reg_offset, src.reg, src.reg_offset);
       break;
    }
 
diff --git a/src/mesa/drivers/dri/i965/gen6_vs_state.c b/src/mesa/drivers/dri/i965/gen6_vs_state.c
index ac783d5df4..31bb57c938 100644
--- a/src/mesa/drivers/dri/i965/gen6_vs_state.c
+++ b/src/mesa/drivers/dri/i965/gen6_vs_state.c
@@ -160,7 +160,7 @@ gen6_upload_push_constants(struct brw_context *brw,
 #else
 #define F "%9f " 
       typedef float TYPE;
-      if (1) {
+      if (0) {
          int i;
          int sz = 0;
          TYPE* p = 0;
diff --git a/src/mesa/drivers/dri/i965/gen7_vs_state.c b/src/mesa/drivers/dri/i965/gen7_vs_state.c
index f07de749fd..e4f8a8de49 100644
--- a/src/mesa/drivers/dri/i965/gen7_vs_state.c
+++ b/src/mesa/drivers/dri/i965/gen7_vs_state.c
@@ -58,7 +58,7 @@ gen7_submit_gather_table(struct brw_context* brw,
    /* Assign subsequent constant buffer slots to UBOs if any */
    cb_valid |= (prog_data->nr_ubo_params > 0) ?
       (2 << (BRW_UBO_GATHER_INDEX_APPEND + prog_data->max_ubo_const_block)) - 1 : 0;
-#if 1
+#if 0
    printf("     Gen %s GT for stage_prog: 0x%x | gt: 0x%x | num: %d |cb_valid: 0x%x\n",
           _mesa_shader_stage_to_string(stage_state->stage),
           prog_data->program,
@@ -120,7 +120,7 @@ gen7_submit_gather_table(struct brw_context* brw,
       OUT_BATCH(SET_FIELD(cb_offset, BRW_GATHER_CONST_BUFFER_OFFSET) |
                 SET_FIELD(prog_data->gather_table[i].channel_mask,
                           BRW_GATHER_CHANNEL_MASK) | bt_offset);
-#if 1
+#if 0
       printf("(%d)       %d|0x%x|%d |uni loc: %d | Nr_params: %d | offset: %d\n", i,
              cb_offset, prog_data->gather_table[i].channel_mask,
              bt_offset,
@@ -151,36 +151,36 @@ gen7_submit_gather_table(struct brw_context* brw,
       components += prog_data->gather_table[i].components;
 
 
-      const float *dx = prog->bo->virtual + prog_data->gather_table[i].const_offset;
-      for (int l = 0; l < 4; l++)
-      {
-         if ((1 << l) & prog_data->gather_table[i].channel_mask) {
-            gather_data[gp++] = dx[l];
-            printf(" %9f ", dx[l]);
-         }
-         if ((l & 7) == 7)
-            printf("\n");
-      }
-      printf("\n");
+      /* const float *dx = prog->bo->virtual + prog_data->gather_table[i].const_offset; */
+      /* for (int l = 0; l < 4; l++) */
+      /* { */
+      /*    if ((1 << l) & prog_data->gather_table[i].channel_mask) { */
+      /*       gather_data[gp++] = dx[l]; */
+      /*       printf(" %9f ", dx[l]); */
+      /*    } */
+      /*    if ((l & 7) == 7) */
+      /*       printf("\n"); */
+      /* } */
+      /* printf("\n"); */
    }
 
-   printf("= Old params=\n");
-   int px = 0;
-   for (int x = 0; x < prog_data->nr_params; x++) {
-      printf(" %9f", (*prog_data->param[x]).f);
-      params[px++] = (*prog_data->param[x]).f;
-      if ((x & 7) == 7)
-         printf("\n");
-   }
-   printf("\n");
-
-   if (memcmp(gather_data, params, sizeof(uint32_t) * prog_data->nr_params) != 0) {
-      for (int m = 0; m < prog_data->nr_params; m++)
-         printf(" %f == %f : %s\n",
-                gather_data[m], params[m],
-                gather_data[m] == params[m] ? "" : "?");
-      assert(0);
-   }
+   /* printf("= Old params=\n"); */
+   /* int px = 0; */
+   /* for (int x = 0; x < prog_data->nr_params; x++) { */
+   /*    printf(" %9f", (*prog_data->param[x]).f); */
+   /*    params[px++] = (*prog_data->param[x]).f; */
+   /*    if ((x & 7) == 7) */
+   /*       printf("\n"); */
+   /* } */
+   /* printf("\n"); */
+
+   /* if (memcmp(gather_data, params, sizeof(uint32_t) * prog_data->nr_params) != 0) { */
+   /*    for (int m = 0; m < prog_data->nr_params; m++) */
+   /*       printf(" %f == %f : %s\n", */
+   /*              gather_data[m], params[m], */
+   /*              gather_data[m] == params[m] ? "" : "?"); */
+   /*    assert(0); */
+   /* } */
 
    /* if (components != prog_data->nr_params) { */
    /*    printf("Components: %d | nrp: %d\n", components, prog_data->nr_params); */