src/gallium/auxiliary/gallivm/lp_bld_arit_overflow.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2013
   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 /**
  30  * @file
  31  * Helper
  32  *
  33  * The functions in this file implement arthmetic operations with support
  34  * for overflow detection and reporting.
  35  *
  36  */
  37
  38 #include "lp_bld_arit_overflow.h"
  39
  40 #include "lp_bld_type.h"
  41 #include "lp_bld_const.h"
  42 #include "lp_bld_init.h"
  43 #include "lp_bld_intr.h"
  44 #include "lp_bld_logic.h"
  45 #include "lp_bld_pack.h"
  46 #include "lp_bld_debug.h"
  47 #include "lp_bld_bitarit.h"
  48
  49 #include "util/u_memory.h"
  50 #include "util/u_debug.h"
  51 #include "util/u_math.h"
  52 #include "util/u_string.h"
  53 #include "util/u_cpu_detect.h"
  54
  55 #include <float.h>
  56
  57
  58 static LLVMValueRef
  59 build_binary_int_overflow(struct gallivm_state *gallivm,
  60                           const char *intr_prefix,
  61                           LLVMValueRef a,
  62                           LLVMValueRef b,
  63                           LLVMValueRef *ofbit)
  64 {
  65    LLVMBuilderRef builder = gallivm->builder;
  66    char intr_str[256];
  67    LLVMTypeRef type_ref;
  68    LLVMTypeKind type_kind;
  69    unsigned type_width;
  70    LLVMTypeRef oelems[2];
  71    LLVMValueRef oresult;
  72    LLVMTypeRef otype;
  73
  74    debug_assert(LLVMTypeOf(a) == LLVMTypeOf(b));
  75    type_ref = LLVMTypeOf(a);
  76    type_kind = LLVMGetTypeKind(type_ref);
  77
  78    debug_assert(type_kind == LLVMIntegerTypeKind);
  79    type_width = LLVMGetIntTypeWidth(type_ref);
  80
  81    debug_assert(type_width == 16 || type_width == 32 || type_width == 64);
  82
  83    snprintf(intr_str, sizeof intr_str, "%s.i%u",
  84             intr_prefix, type_width);
  85
  86    oelems[0] = type_ref;
  87    oelems[1] = LLVMInt1TypeInContext(gallivm->context);
  88
  89    otype = LLVMStructTypeInContext(gallivm->context, oelems, 2, FALSE);
  90    oresult = lp_build_intrinsic_binary(builder, intr_str,
  91                                        otype, a, b);
  92    if (ofbit) {
  93       if (*ofbit) {
  94          *ofbit = LLVMBuildOr(
  95             builder, *ofbit,
  96             LLVMBuildExtractValue(builder, oresult, 1, ""), "");
  97       } else {
  98          *ofbit = LLVMBuildExtractValue(builder, oresult, 1, "");
  99       }
 100    }
 101
 102    return LLVMBuildExtractValue(builder, oresult, 0, "");
 103 }
 104
 105 /**
 106  * Performs unsigned addition of two integers and reports
 107  * overflow if detected.
 108  *
 109  * The values @a and @b must be of the same integer type. If
 110  * an overflow is detected the IN/OUT @ofbit parameter is used:
 111  * - if it's pointing to a null value, the overflow bit is simply
 112  *   stored inside the variable it's pointing to,
 113  * - if it's pointing to a valid value, then that variable,
 114  *   which must be of i1 type, is ORed with the newly detected
 115  *   overflow bit. This is done to allow chaining of a number of
 116  *   overflow functions together without having to test the
 117  *   overflow bit after every single one.
 118  */
 119 LLVMValueRef
 120 lp_build_uadd_overflow(struct gallivm_state *gallivm,
 121                        LLVMValueRef a,
 122                        LLVMValueRef b,
 123                        LLVMValueRef *ofbit)
 124 {
 125    return build_binary_int_overflow(gallivm, "llvm.uadd.with.overflow",
 126                                     a, b, ofbit);
 127 }
 128
 129 /**
 130  * Performs unsigned subtraction of two integers and reports
 131  * overflow if detected.
 132  *
 133  * The values @a and @b must be of the same integer type. If
 134  * an overflow is detected the IN/OUT @ofbit parameter is used:
 135  * - if it's pointing to a null value, the overflow bit is simply
 136  *   stored inside the variable it's pointing to,
 137  * - if it's pointing to a valid value, then that variable,
 138  *   which must be of i1 type, is ORed with the newly detected
 139  *   overflow bit. This is done to allow chaining of a number of
 140  *   overflow functions together without having to test the
 141  *   overflow bit after every single one.
 142  */
 143 LLVMValueRef
 144 lp_build_usub_overflow(struct gallivm_state *gallivm,
 145                        LLVMValueRef a,
 146                        LLVMValueRef b,
 147                        LLVMValueRef *ofbit)
 148 {
 149    return build_binary_int_overflow(gallivm, "llvm.usub.with.overflow",
 150                                     a, b, ofbit);
 151 }
 152
 153 /**
 154  * Performs unsigned multiplication of  two integers and
 155  * reports overflow if detected.
 156  *
 157  * The values @a and @b must be of the same integer type. If
 158  * an overflow is detected the IN/OUT @ofbit parameter is used:
 159  * - if it's pointing to a null value, the overflow bit is simply
 160  *   stored inside the variable it's pointing to,
 161  * - if it's pointing to a valid value, then that variable,
 162  *   which must be of i1 type, is ORed with the newly detected
 163  *   overflow bit. This is done to allow chaining of a number of
 164  *   overflow functions together without having to test the
 165  *   overflow bit after every single one.
 166  */
 167 LLVMValueRef
 168 lp_build_umul_overflow(struct gallivm_state *gallivm,
 169                        LLVMValueRef a,
 170                        LLVMValueRef b,
 171                        LLVMValueRef *ofbit)
 172 {
 173    return build_binary_int_overflow(gallivm, "llvm.umul.with.overflow",
 174                                     a, b, ofbit);
 175 }