src/gallium/drivers/llvmpipe/lp_bld_type.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2009 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28
  29 #include "util/u_debug.h"
  30
  31 #include "lp_bld_type.h"
  32 #include "lp_bld_const.h"
  33
  34
  35 LLVMTypeRef
  36 lp_build_elem_type(struct lp_type type)
  37 {
  38    if (type.floating) {
  39       switch(type.width) {
  40       case 32:
  41          return LLVMFloatType();
  42          break;
  43       case 64:
  44          return LLVMDoubleType();
  45          break;
  46       default:
  47          assert(0);
  48          return LLVMFloatType();
  49       }
  50    }
  51    else {
  52       return LLVMIntType(type.width);
  53    }
  54 }
  55
  56
  57 LLVMTypeRef
  58 lp_build_vec_type(struct lp_type type)
  59 {
  60    LLVMTypeRef elem_type = lp_build_elem_type(type);
  61    return LLVMVectorType(elem_type, type.length);
  62 }
  63
  64
  65 /**
  66  * This function is a mirror of lp_build_elem_type() above.
  67  *
  68  * XXX: I'm not sure if it wouldn't be easier/efficient to just recreate the
  69  * type and check for identity.
  70  */
  71 boolean
  72 lp_check_elem_type(struct lp_type type, LLVMTypeRef elem_type)
  73 {
  74    LLVMTypeKind elem_kind;
  75
  76    assert(elem_type);
  77    if(!elem_type)
  78       return FALSE;
  79
  80    elem_kind = LLVMGetTypeKind(elem_type);
  81
  82    if (type.floating) {
  83       switch(type.width) {
  84       case 32:
  85          if(elem_kind != LLVMFloatTypeKind)
  86             return FALSE;
  87          break;
  88       case 64:
  89          if(elem_kind != LLVMDoubleTypeKind)
  90             return FALSE;
  91          break;
  92       default:
  93          assert(0);
  94          return FALSE;
  95       }
  96    }
  97    else {
  98       if(elem_kind != LLVMIntegerTypeKind)
  99          return FALSE;
 100
 101       if(LLVMGetIntTypeWidth(elem_type) != type.width)
 102          return FALSE;
 103    }
 104
 105    return TRUE;
 106 }
 107
 108
 109 boolean
 110 lp_check_vec_type(struct lp_type type, LLVMTypeRef vec_type)
 111 {
 112    LLVMTypeRef elem_type;
 113
 114    assert(vec_type);
 115    if(!vec_type)
 116       return FALSE;
 117
 118    if(LLVMGetTypeKind(vec_type) != LLVMVectorTypeKind)
 119       return FALSE;
 120
 121    if(LLVMGetVectorSize(vec_type) != type.length)
 122       return FALSE;
 123
 124    elem_type = LLVMGetElementType(vec_type);
 125
 126    return lp_check_elem_type(type, elem_type);
 127 }
 128
 129
 130 boolean
 131 lp_check_value(struct lp_type type, LLVMValueRef val)
 132 {
 133    LLVMTypeRef vec_type;
 134
 135    assert(val);
 136    if(!val)
 137       return FALSE;
 138
 139    vec_type = LLVMTypeOf(val);
 140
 141    return lp_check_vec_type(type, vec_type);
 142 }
 143
 144
 145 LLVMTypeRef
 146 lp_build_int_elem_type(struct lp_type type)
 147 {
 148    return LLVMIntType(type.width);
 149 }
 150
 151
 152 LLVMTypeRef
 153 lp_build_int_vec_type(struct lp_type type)
 154 {
 155    LLVMTypeRef elem_type = lp_build_int_elem_type(type);
 156    return LLVMVectorType(elem_type, type.length);
 157 }
 158
 159
 160 struct lp_type
 161 lp_int_type(struct lp_type type)
 162 {
 163    struct lp_type res_type;
 164
 165    memset(&res_type, 0, sizeof res_type);
 166    res_type.width = type.width;
 167    res_type.length = type.length;
 168
 169    return res_type;
 170 }
 171
 172
 173 /**
 174  * Return the type with twice the bit width (hence half the number of elements).
 175  */
 176 struct lp_type
 177 lp_wider_type(struct lp_type type)
 178 {
 179    struct lp_type res_type;
 180
 181    memcpy(&res_type, &type, sizeof res_type);
 182    res_type.width *= 2;
 183    res_type.length /= 2;
 184
 185    assert(res_type.length);
 186
 187    return res_type;
 188 }
 189
 190
 191 void
 192 lp_build_context_init(struct lp_build_context *bld,
 193                       LLVMBuilderRef builder,
 194                       struct lp_type type)
 195 {
 196    bld->builder = builder;
 197    bld->type = type;
 198    bld->undef = lp_build_undef(type);
 199    bld->zero = lp_build_zero(type);
 200    bld->one = lp_build_one(type);
 201 }