cell_vertex_fetch.c File Reference

Include dependency graph for cell_vertex_fetch.c:

Go to the source code of this file.

Functions
static void	emit_matrix_transpose (struct spe_function *p, unsigned row0, unsigned row1, unsigned row2, unsigned row3, unsigned dest_ptr, unsigned shuf_ptr, unsigned count)
	Emit a 4x4 matrix transpose operation.
static void	emit_fetch (struct spe_function *p, unsigned in_ptr, unsigned *offset, unsigned out_ptr, unsigned shuf_ptr, enum pipe_format format)
void	cell_update_vertex_fetch (struct draw_context *draw)

---

Function Documentation

void cell_update_vertex_fetch

(

struct draw_context *

draw

)

Definition at line 261 of file cell_vertex_fetch.c.

References align(), assert, cell_context::attrib_fetch, cell_context::attrib_fetch_offsets, draw_context::driver_private, emit_fetch(), offset(), PIPE_MAX_ATTRIBS, spe_allocate_register(), spe_bi(), spe_init_func(), SPE_INST_SIZE, pipe_vertex_element::src_format, and draw_context::vertex_element.

{
#if 0
   struct cell_context *const cell =
       (struct cell_context *) draw->driver_private;
   struct spe_function *p = &cell->attrib_fetch;
   unsigned function_index[PIPE_MAX_ATTRIBS];
   unsigned unique_attr_formats;
   int out_ptr;
   int in_ptr;
   int shuf_ptr;
   unsigned i;
   unsigned j;


   /* Determine how many unique input attribute formats there are.  At the
    * same time, store the index of the lowest numbered attribute that has
    * the same format as any non-unique format.
    */
   unique_attr_formats = 1;
   function_index[0] = 0;
   for (i = 1; i < draw->vertex_fetch.nr_attrs; i++) {
      const enum pipe_format curr_fmt = draw->vertex_element[i].src_format;

      for (j = 0; j < i; j++) {
         if (curr_fmt == draw->vertex_element[j].src_format) {
            break;
         }
      }
      
      if (j == i) {
         unique_attr_formats++;
      }

      function_index[i] = j;
   }


   /* Each fetch function can be a maximum of 34 instructions (note: this is
    * actually a slight over-estimate).
    */
   spe_init_func(p, 34 * SPE_INST_SIZE * unique_attr_formats);


   /* Allocate registers for the function's input parameters.
    */
   out_ptr = spe_allocate_register(p, 3);
   in_ptr = spe_allocate_register(p, 4);
   shuf_ptr = spe_allocate_register(p, 5);


   /* Generate code for the individual attribute fetch functions.
    */
   for (i = 0; i < draw->vertex_fetch.nr_attrs; i++) {
      unsigned offset;

      if (function_index[i] == i) {
         cell->attrib_fetch_offsets[i] = (unsigned) ((void *) p->csr 
                                                     - (void *) p->store);

         offset = 0;
         emit_fetch(p, in_ptr, &offset, out_ptr, shuf_ptr,
                    draw->vertex_element[i].src_format);
         spe_bi(p, 0, 0, 0);

         /* Round up to the next 16-byte boundary.
          */
         if ((((unsigned) p->store) & 0x0f) != 0) {
            const unsigned align = ((unsigned) p->store) & 0x0f;
            p->store = (uint32_t *) (((void *) p->store) + align);
         }
      } else {
         /* Use the same function entry-point as a previously seen attribute
          * with the same format.
          */
         cell->attrib_fetch_offsets[i] = 
             cell->attrib_fetch_offsets[function_index[i]];
      }
   }
#else
   assert(0);
#endif
}

static void emit_fetch	(	struct spe_function *	p,
		unsigned	in_ptr,
		unsigned *	offset,
		unsigned	out_ptr,
		unsigned	shuf_ptr,
		enum pipe_format	format
	)			[static]

Definition at line 149 of file cell_vertex_fetch.c.

References assert, emit_matrix_transpose(), pf_size_w, pf_size_x, pf_size_y, pf_size_z, pf_type, PIPE_FORMAT_TYPE_FLOAT, PIPE_FORMAT_TYPE_SNORM, PIPE_FORMAT_TYPE_SSCALED, PIPE_FORMAT_TYPE_UNORM, PIPE_FORMAT_TYPE_USCALED, spe_allocate_available_register(), spe_csflt(), spe_cuflt(), spe_fm(), spe_il(), spe_ilhu(), spe_iohl(), spe_lqd(), spe_release_register(), spe_shufb(), and spe_stqd().

{
   const unsigned count = (pf_size_x(format) != 0) + (pf_size_y(format) != 0)
       + (pf_size_z(format) != 0) + (pf_size_w(format) != 0);
   const unsigned type = pf_type(format);
   const unsigned bytes = pf_size_x(format);

   int v0 = spe_allocate_available_register(p);
   int v1 = spe_allocate_available_register(p);
   int v2 = spe_allocate_available_register(p);
   int v3 = spe_allocate_available_register(p);
   int tmp = spe_allocate_available_register(p);
   int float_zero = -1;
   int float_one = -1;
   float scale_signed = 0.0;
   float scale_unsigned = 0.0;

   spe_lqd(p, v0, in_ptr, 0 + offset[0]);
   spe_lqd(p, v1, in_ptr, 1 + offset[0]);
   spe_lqd(p, v2, in_ptr, 2 + offset[0]);
   spe_lqd(p, v3, in_ptr, 3 + offset[0]);
   offset[0] += 4;
   
   switch (bytes) {
   case 1:
      scale_signed = 1.0f / 127.0f;
      scale_unsigned = 1.0f / 255.0f;
      spe_lqd(p, tmp, shuf_ptr, 1);
      spe_shufb(p, v0, v0, v0, tmp);
      spe_shufb(p, v1, v1, v1, tmp);
      spe_shufb(p, v2, v2, v2, tmp);
      spe_shufb(p, v3, v3, v3, tmp);
      break;
   case 2:
      scale_signed = 1.0f / 32767.0f;
      scale_unsigned = 1.0f / 65535.0f;
      spe_lqd(p, tmp, shuf_ptr, 2);
      spe_shufb(p, v0, v0, v0, tmp);
      spe_shufb(p, v1, v1, v1, tmp);
      spe_shufb(p, v2, v2, v2, tmp);
      spe_shufb(p, v3, v3, v3, tmp);
      break;
   case 4:
      scale_signed = 1.0f / 2147483647.0f;
      scale_unsigned = 1.0f / 4294967295.0f;
      break;
   default:
      assert(0);
      break;
   }

   switch (type) {
   case PIPE_FORMAT_TYPE_FLOAT:
      break;
   case PIPE_FORMAT_TYPE_UNORM:
      spe_ilhu(p, tmp, ((unsigned) scale_unsigned) >> 16);
      spe_iohl(p, tmp, ((unsigned) scale_unsigned) & 0x0ffff);
      spe_cuflt(p, v0, v0, 0);
      spe_fm(p, v0, v0, tmp);
      break;
   case PIPE_FORMAT_TYPE_SNORM:
      spe_ilhu(p, tmp, ((unsigned) scale_signed) >> 16);
      spe_iohl(p, tmp, ((unsigned) scale_signed) & 0x0ffff);
      spe_csflt(p, v0, v0, 0);
      spe_fm(p, v0, v0, tmp);
      break;
   case PIPE_FORMAT_TYPE_USCALED:
      spe_cuflt(p, v0, v0, 0);
      break;
   case PIPE_FORMAT_TYPE_SSCALED:
      spe_csflt(p, v0, v0, 0);
      break;
   }


   if (count < 4) {
      float_one = spe_allocate_available_register(p);
      spe_il(p, float_one, 1);
      spe_cuflt(p, float_one, float_one, 0);
      
      if (count < 3) {
         float_zero = spe_allocate_available_register(p);
         spe_il(p, float_zero, 0);
      }
   }

   spe_release_register(p, tmp);

   emit_matrix_transpose(p, v0, v1, v2, v3, out_ptr, shuf_ptr, count);

   switch (count) {
   case 1:
      spe_stqd(p, float_zero, out_ptr, 1);
   case 2:
      spe_stqd(p, float_zero, out_ptr, 2);
   case 3:
      spe_stqd(p, float_one, out_ptr, 3);
   }

   if (float_zero != -1) {
      spe_release_register(p, float_zero);
   }

   if (float_one != -1) {
      spe_release_register(p, float_one);
   }
}

static void emit_matrix_transpose	(	struct spe_function *	p,
		unsigned	row0,
		unsigned	row1,
		unsigned	row2,
		unsigned	row3,
		unsigned	dest_ptr,
		unsigned	shuf_ptr,
		unsigned	count
	)			[static]

Emit a 4x4 matrix transpose operation.

Parameters:

	p	Function that the transpose operation is to be appended to
	row0	Register containing row 0 of the source matrix
	row1	Register containing row 1 of the source matrix
	row2	Register containing row 2 of the source matrix
	row3	Register containing row 3 of the source matrix
	dest_ptr	Register containing the address of the destination matrix
	shuf_ptr	Register containing the address of the shuffled data
	count	Number of colums to actually be written to the destination

Note:

This function assumes that the registers named by row0, row1, row2, and row3 are scratch and can be modified by the generated code. Furthermore, these registers will be released, via calls to release_register, by this function.

This function requires that four temporary are available on entry.

Definition at line 59 of file cell_vertex_fetch.c.

References spe_allocate_available_register(), spe_lqd(), spe_release_register(), spe_shufb(), and spe_stqd().

{
   int shuf_hi = spe_allocate_available_register(p);
   int shuf_lo = spe_allocate_available_register(p);
   int t1 = spe_allocate_available_register(p);
   int t2 = spe_allocate_available_register(p);
   int t3;
   int t4;
   int col0;
   int col1;
   int col2;
   int col3;


   spe_lqd(p, shuf_hi, shuf_ptr, 3);
   spe_lqd(p, shuf_lo, shuf_ptr, 4);
   spe_shufb(p, t1, row0, row2, shuf_hi);
   spe_shufb(p, t2, row0, row2, shuf_lo);


   /* row0 and row2 are now no longer needed.  Re-use those registers as
    * temporaries.
    */
   t3 = row0;
   t4 = row2;

   spe_shufb(p, t3, row1, row3, shuf_hi);
   spe_shufb(p, t4, row1, row3, shuf_lo);


   /* row1 and row3 are now no longer needed.  Re-use those registers as
    * temporaries.
    */
   col0 = row1;
   col1 = row3;

   spe_shufb(p, col0, t1, t3, shuf_hi);
   if (count > 1) {
      spe_shufb(p, col1, t1, t3, shuf_lo);
   }

   /* t1 and t3 are now no longer needed.  Re-use those registers as
    * temporaries.
    */
   col2 = t1;
   col3 = t3;

   if (count > 2) {
      spe_shufb(p, col2, t2, t4, shuf_hi);
   }

   if (count > 3) {
      spe_shufb(p, col3, t2, t4, shuf_lo);
   }


   /* Store the results.  Remember that the stqd instruction is encoded using
    * the qword offset (stand-alone assemblers to the byte-offset to
    * qword-offset conversion for you), so the byte-offset needs be divided by
    * 16.
    */
   switch (count) {
   case 4:
      spe_stqd(p, col3, dest_ptr, 3);
   case 3:
      spe_stqd(p, col2, dest_ptr, 2);
   case 2:
      spe_stqd(p, col1, dest_ptr, 1);
   case 1:
      spe_stqd(p, col0, dest_ptr, 0);
   }


   /* Release all of the temporary registers used.
    */
   spe_release_register(p, col0);
   spe_release_register(p, col1);
   spe_release_register(p, col2);
   spe_release_register(p, col3);
   spe_release_register(p, shuf_hi);
   spe_release_register(p, shuf_lo);
   spe_release_register(p, t2);
   spe_release_register(p, t4);
}

---