path: root/src/gallium/auxiliary/gallivm/lp_bld_type.h

/**************************************************************************
 *
 * Copyright 2009 VMware, Inc.
 * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 **************************************************************************/

/**
 * @file
 * Convenient representation of SIMD types.
 *
 * @author Jose Fonseca <jfonseca@vmware.com>
 */


#ifndef LP_BLD_TYPE_H
#define LP_BLD_TYPE_H


#include "util/u_format.h"
#include "pipe/p_compiler.h"
#include "gallivm/lp_bld.h"

/**
 * Native SIMD architecture width available at runtime.
 *
 * Using this width should give the best performance,
 * and it determines the necessary alignment of vector variables.
 */
extern unsigned lp_native_vector_width;

/**
 * Maximum supported vector width (not necessarily supported at run-time).
 *
 * Should only be used when lp_native_vector_width isn't available,
 * i.e. sizing/alignment of non-malloced variables.
 */
#define LP_MAX_VECTOR_WIDTH 256

/**
 * Minimum vector alignment for static variable alignment
 *
 * It should always be a constant equal to LP_MAX_VECTOR_WIDTH/8.  An
 * expression is non-portable.
 */
#define LP_MIN_VECTOR_ALIGN 32

/**
 * Several functions can only cope with vectors of length up to this value.
 * You may need to increase that value if you want to represent bigger vectors.
 */
#define LP_MAX_VECTOR_LENGTH (LP_MAX_VECTOR_WIDTH/8)

/**
 * The LLVM type system can't conveniently express all the things we care about
 * on the types used for intermediate computations, such as signed vs unsigned,
 * normalized values, or fixed point.
 */
struct lp_type {
   /**
    * Floating-point. Cannot be used with fixed. Integer numbers are
    * represented by this zero.
    */
   unsigned floating:1;

   /**
    * Fixed-point. Cannot be used with floating. Integer numbers are
    * represented by this zero.
    */
   unsigned fixed:1;

   /**
    * Whether it can represent negative values or not.
    *
    * If this is not set for floating point, it means that all values are
    * assumed to be positive.
    */
   unsigned sign:1;

   /**
    * Whether values are normalized to fit [0, 1] interval, or [-1, 1]
    * interval for signed types.
    *
    * For integer types it means the representable integer range should be
    * interpreted as the interval above.
    *
    * For floating and fixed point formats it means the values should be
    * clamped to the interval above.
    */
   unsigned norm:1;

   /**
    * Element width.
    *
    * For fixed point values, the fixed point is assumed to be at half the
    * width.
    */
   unsigned width:14;

   /**
    * Vector length.  If length==1, this is a scalar (float/int) type.
    *
    * width*length should be a power of two greater or equal to eight.
    *
    * @sa LP_MAX_VECTOR_LENGTH
    */
   unsigned length:14;
};


/**
 * We need most of the information here in order to correctly and efficiently
 * translate an arithmetic operation into LLVM IR. Putting it here avoids the
 * trouble of passing it as parameters.
 */
struct lp_build_context
{
   struct gallivm_state *gallivm;

   /**
    * This not only describes the input/output LLVM types, but also whether
    * to normalize/clamp the results.
    */
   struct lp_type type;

   /** Same as lp_build_elem_type(type) */
   LLVMTypeRef elem_type;

   /** Same as lp_build_vec_type(type) */
   LLVMTypeRef vec_type;

   /** Same as lp_build_int_elem_type(type) */
   LLVMTypeRef int_elem_type;

   /** Same as lp_build_int_vec_type(type) */
   LLVMTypeRef int_vec_type;

   /** Same as lp_build_undef(type) */
   LLVMValueRef undef;

   /** Same as lp_build_zero(type) */
   LLVMValueRef zero;

   /** Same as lp_build_one(type) */
   LLVMValueRef one;
};


/**
 * Converts a format description into an lp_type.
 *
 * Only works with "array formats".
 *
 * e.g. With PIPE_FORMAT_R32G32B32A32_FLOAT returns an lp_type with float[4]
 */
static INLINE void
lp_type_from_format_desc(struct lp_type* type, const struct util_format_description *format_desc)
{
   assert(format_desc->is_array);
   assert(!format_desc->is_mixed);

   memset(type, 0, sizeof(struct lp_type));
   type->floating = format_desc->channel[0].type == UTIL_FORMAT_TYPE_FLOAT;
   type->fixed    = format_desc->channel[0].type == UTIL_FORMAT_TYPE_FIXED;
   type->sign     = format_desc->channel[0].type != UTIL_FORMAT_TYPE_UNSIGNED;
   type->norm     = format_desc->channel[0].normalized;
   type->width    = format_desc->channel[0].size;
   type->length   = format_desc->nr_channels;
}


static INLINE void
lp_type_from_format(struct lp_type* type, enum pipe_format format)
{
   lp_type_from_format_desc(type, util_format_description(format));
}


static INLINE unsigned
lp_type_width(struct lp_type type)
{
   return type.width * type.length;
}


/** Create scalar float type */
static INLINE struct lp_type
lp_type_float(unsigned width)
{
   struct lp_type res_type;

   memset(&res_type, 0, sizeof res_type);
   res_type.floating = TRUE;
   res_type.sign = TRUE;
   res_type.width = width;
   res_type.length = 1;

   return res_type;
}


/** Create vector of float type */
static INLINE struct lp_type
lp_type_float_vec(unsigned width, unsigned total_width)
{
   struct lp_type res_type;

   memset(&res_type, 0, sizeof res_type);
   res_type.floating = TRUE;
   res_type.sign = TRUE;
   res_type.width = width;
   res_type.length = total_width / width;

   return res_type;
}


/** Create scalar int type */
static INLINE struct lp_type
lp_type_int(unsigned width)
{
   struct lp_type res_type;

   memset(&res_type, 0, sizeof res_type);
   res_type.sign = TRUE;
   res_type.width = width;
   res_type.length = 1;

   return res_type;
}


/** Create vector int type */
static INLINE struct lp_type
lp_type_int_vec(unsigned width, unsigned total_width)
{
   struct lp_type res_type;

   memset(&res_type, 0, sizeof res_type);
   res_type.sign = TRUE;
   res_type.width = width;
   res_type.length = total_width / width;

   return res_type;
}


/** Create scalar uint type */
static INLINE struct lp_type
lp_type_uint(unsigned width)
{
   struct lp_type res_type;

   memset(&res_type, 0, sizeof res_type);
   res_type.width = width;
   res_type.length = 1;

   return res_type;
}


/** Create vector uint type */
static INLINE struct lp_type
lp_type_uint_vec(unsigned width, unsigned total_width)
{
   struct lp_type res_type;

   memset(&res_type, 0, sizeof res_type);
   res_type.width = width;
   res_type.length = total_width / width;

   return res_type;
}


static INLINE struct lp_type
lp_type_unorm(unsigned width, unsigned total_width)
{
   struct lp_type res_type;

   memset(&res_type, 0, sizeof res_type);
   res_type.norm = TRUE;
   res_type.width = width;
   res_type.length = total_width / width;

   return res_type;
}


static INLINE struct lp_type
lp_type_fixed(unsigned width, unsigned total_width)
{
   struct lp_type res_type;

   memset(&res_type, 0, sizeof res_type);
   res_type.sign = TRUE;
   res_type.fixed = TRUE;
   res_type.width = width;
   res_type.length = total_width / width;

   return res_type;
}


static INLINE struct lp_type
lp_type_ufixed(unsigned width, unsigned total_width)
{
   struct lp_type res_type;

   memset(&res_type, 0, sizeof res_type);
   res_type.fixed = TRUE;
   res_type.width = width;
   res_type.length = total_width / width;

   return res_type;
}


LLVMTypeRef
lp_build_elem_type(struct gallivm_state *gallivm, struct lp_type type);


LLVMTypeRef
lp_build_vec_type(struct gallivm_state *gallivm, struct lp_type type);


boolean
lp_check_elem_type(struct lp_type type, LLVMTypeRef elem_type);


boolean
lp_check_vec_type(struct lp_type type, LLVMTypeRef vec_type);


boolean
lp_check_value(struct lp_type type, LLVMValueRef val);


LLVMTypeRef
lp_build_int_elem_type(struct gallivm_state *gallivm, struct lp_type type);


LLVMTypeRef
lp_build_int_vec_type(struct gallivm_state *gallivm, struct lp_type type);


static INLINE struct lp_type
lp_float32_vec4_type(void)
{
   struct lp_type type;

   memset(&type, 0, sizeof(type));
   type.floating = TRUE;
   type.sign = TRUE;
   type.norm = FALSE;
   type.width = 32;
   type.length = 4;

   return type;
}


static INLINE struct lp_type
lp_int32_vec4_type(void)
{
   struct lp_type type;

   memset(&type, 0, sizeof(type));
   type.floating = FALSE;
   type.sign = TRUE;
   type.norm = FALSE;
   type.width = 32;
   type.length = 4;

   return type;
}


static INLINE struct lp_type
lp_unorm8_vec4_type(void)
{
   struct lp_type type;

   memset(&type, 0, sizeof(type));
   type.floating = FALSE;
   type.sign = FALSE;
   type.norm = TRUE;
   type.width = 8;
   type.length = 4;

   return type;
}


struct lp_type
lp_elem_type(struct lp_type type);


struct lp_type
lp_uint_type(struct lp_type type);


struct lp_type
lp_int_type(struct lp_type type);


struct lp_type
lp_wider_type(struct lp_type type);


unsigned
lp_sizeof_llvm_type(LLVMTypeRef t);


const char *
lp_typekind_name(LLVMTypeKind t);


void
lp_dump_llvmtype(LLVMTypeRef t);


void
lp_build_context_init(struct lp_build_context *bld,
                      struct gallivm_state *gallivm,
                      struct lp_type type);


unsigned
lp_build_count_ir_module(LLVMModuleRef module);


#endif /* !LP_BLD_TYPE_H */