Home | History | Annotate | Download | only in gallivm 
      1 /**************************************************************************
      2  *
      3  * Copyright 2010 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 SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     16  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
     17  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
     18  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
     19  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
     20  * USE OR OTHER DEALINGS IN THE SOFTWARE.
     21  *
     22  * The above copyright notice and this permission notice (including the
     23  * next paragraph) shall be included in all copies or substantial portions
     24  * of the Software.
     25  *
     26  **************************************************************************/
     27 
     28 
     29 #include "util/u_debug.h"
     30 
     31 #include "lp_bld_type.h"
     32 #include "lp_bld_debug.h"
     33 #include "lp_bld_const.h"
     34 #include "lp_bld_bitarit.h"
     35 
     36 
     37 /**
     38  * Return (a | b)
     39  */
     40 LLVMValueRef
     41 lp_build_or(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
     42 {
     43    LLVMBuilderRef builder = bld->gallivm->builder;
     44    const struct lp_type type = bld->type;
     45    LLVMValueRef res;
     46 
     47    assert(lp_check_value(type, a));
     48    assert(lp_check_value(type, b));
     49 
     50    /* can't do bitwise ops on floating-point values */
     51    if (type.floating) {
     52       a = LLVMBuildBitCast(builder, a, bld->int_vec_type, "");
     53       b = LLVMBuildBitCast(builder, b, bld->int_vec_type, "");
     54    }
     55 
     56    res = LLVMBuildOr(builder, a, b, "");
     57 
     58    if (type.floating) {
     59       res = LLVMBuildBitCast(builder, res, bld->vec_type, "");
     60    }
     61 
     62    return res;
     63 }
     64 
     65 /* bitwise XOR (a ^ b) */
     66 LLVMValueRef
     67 lp_build_xor(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
     68 {
     69    LLVMBuilderRef builder = bld->gallivm->builder;
     70    const struct lp_type type = bld->type;
     71    LLVMValueRef res;
     72 
     73    assert(lp_check_value(type, a));
     74    assert(lp_check_value(type, b));
     75 
     76    /* can't do bitwise ops on floating-point values */
     77    if (type.floating) {
     78       a = LLVMBuildBitCast(builder, a, bld->int_vec_type, "");
     79       b = LLVMBuildBitCast(builder, b, bld->int_vec_type, "");
     80    }
     81 
     82    res = LLVMBuildXor(builder, a, b, "");
     83 
     84    if (type.floating) {
     85       res = LLVMBuildBitCast(builder, res, bld->vec_type, "");
     86    }
     87 
     88    return res;
     89 }
     90 
     91 /**
     92  * Return (a & b)
     93  */
     94 LLVMValueRef
     95 lp_build_and(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
     96 {
     97    LLVMBuilderRef builder = bld->gallivm->builder;
     98    const struct lp_type type = bld->type;
     99    LLVMValueRef res;
    100 
    101    assert(lp_check_value(type, a));
    102    assert(lp_check_value(type, b));
    103 
    104    /* can't do bitwise ops on floating-point values */
    105    if (type.floating) {
    106       a = LLVMBuildBitCast(builder, a, bld->int_vec_type, "");
    107       b = LLVMBuildBitCast(builder, b, bld->int_vec_type, "");
    108    }
    109 
    110    res = LLVMBuildAnd(builder, a, b, "");
    111 
    112    if (type.floating) {
    113       res = LLVMBuildBitCast(builder, res, bld->vec_type, "");
    114    }
    115 
    116    return res;
    117 }
    118 
    119 
    120 /**
    121  * Return (a & ~b)
    122  */
    123 LLVMValueRef
    124 lp_build_andnot(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
    125 {
    126    LLVMBuilderRef builder = bld->gallivm->builder;
    127    const struct lp_type type = bld->type;
    128    LLVMValueRef res;
    129 
    130    assert(lp_check_value(type, a));
    131    assert(lp_check_value(type, b));
    132 
    133    /* can't do bitwise ops on floating-point values */
    134    if (type.floating) {
    135       a = LLVMBuildBitCast(builder, a, bld->int_vec_type, "");
    136       b = LLVMBuildBitCast(builder, b, bld->int_vec_type, "");
    137    }
    138 
    139    res = LLVMBuildNot(builder, b, "");
    140    res = LLVMBuildAnd(builder, a, res, "");
    141 
    142    if (type.floating) {
    143       res = LLVMBuildBitCast(builder, res, bld->vec_type, "");
    144    }
    145 
    146    return res;
    147 }
    148 
    149 /* bitwise NOT */
    150 LLVMValueRef
    151 lp_build_not(struct lp_build_context *bld, LLVMValueRef a)
    152 {
    153    LLVMBuilderRef builder = bld->gallivm->builder;
    154    const struct lp_type type = bld->type;
    155    LLVMValueRef res;
    156 
    157    assert(lp_check_value(type, a));
    158 
    159    if (type.floating) {
    160       a = LLVMBuildBitCast(builder, a, bld->int_vec_type, "");
    161    }
    162    res = LLVMBuildNot(builder, a, "");
    163    if (type.floating) {
    164       res = LLVMBuildBitCast(builder, res, bld->vec_type, "");
    165    }
    166    return res;
    167 }
    168 
    169 /**
    170  * Shift left.
    171  */
    172 LLVMValueRef
    173 lp_build_shl(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
    174 {
    175    LLVMBuilderRef builder = bld->gallivm->builder;
    176    const struct lp_type type = bld->type;
    177    LLVMValueRef res;
    178 
    179    assert(!type.floating);
    180 
    181    assert(lp_check_value(type, a));
    182    assert(lp_check_value(type, b));
    183 
    184    res = LLVMBuildShl(builder, a, b, "");
    185 
    186    return res;
    187 }
    188 
    189 
    190 /**
    191  * Shift right.
    192  */
    193 LLVMValueRef
    194 lp_build_shr(struct lp_build_context *bld, LLVMValueRef a, LLVMValueRef b)
    195 {
    196    LLVMBuilderRef builder = bld->gallivm->builder;
    197    const struct lp_type type = bld->type;
    198    LLVMValueRef res;
    199 
    200    assert(!type.floating);
    201 
    202    assert(lp_check_value(type, a));
    203    assert(lp_check_value(type, b));
    204 
    205    if (type.sign) {
    206       res = LLVMBuildAShr(builder, a, b, "");
    207    } else {
    208       res = LLVMBuildLShr(builder, a, b, "");
    209    }
    210 
    211    return res;
    212 }
    213 
    214 
    215 /**
    216  * Shift left with immediate.
    217  */
    218 LLVMValueRef
    219 lp_build_shl_imm(struct lp_build_context *bld, LLVMValueRef a, unsigned imm)
    220 {
    221    LLVMValueRef b = lp_build_const_int_vec(bld->gallivm, bld->type, imm);
    222    assert(imm <= bld->type.width);
    223    return lp_build_shl(bld, a, b);
    224 }
    225 
    226 
    227 /**
    228  * Shift right with immediate.
    229  */
    230 LLVMValueRef
    231 lp_build_shr_imm(struct lp_build_context *bld, LLVMValueRef a, unsigned imm)
    232 {
    233    LLVMValueRef b = lp_build_const_int_vec(bld->gallivm, bld->type, imm);
    234    assert(imm <= bld->type.width);
    235    return lp_build_shr(bld, a, b);
    236 }
    237