rev 52889 : 8214023: Update Graal

   1 /*
   2  * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 
  25 package org.graalvm.compiler.core.common;
  26 
  27 // JaCoCo Exclude
  28 
  29 import jdk.vm.ci.code.CodeUtil;
  30 
  31 /**
  32  * A collection of static utility functions that check ranges of numbers.
  33  */
  34 public class NumUtil {
  35 
  36     public static boolean isShiftCount(int x) {
  37         return 0 <= x && x < 32;
  38     }
  39 
  40     /**
  41      * Determines if a given {@code int} value is the range of unsigned byte values.
  42      */
  43     public static boolean isUByte(int x) {
  44         return (x & 0xff) == x;
  45     }
  46 
  47     /**
  48      * Determines if a given {@code int} value is the range of signed byte values.
  49      */
  50     public static boolean isByte(int x) {
  51         return (byte) x == x;
  52     }
  53 
  54     /**
  55      * Determines if a given {@code long} value is the range of unsigned byte values.
  56      */
  57     public static boolean isUByte(long x) {
  58         return (x & 0xffL) == x;
  59     }
  60 
  61     /**
  62      * Determines if a given {@code long} value is the range of signed byte values.
  63      */
  64     public static boolean isByte(long l) {
  65         return (byte) l == l;
  66     }
  67 
  68     /**
  69      * Determines if a given {@code long} value is the range of unsigned int values.
  70      */
  71     public static boolean isUInt(long x) {
  72         return (x & 0xffffffffL) == x;
  73     }
  74 
  75     /**
  76      * Determines if a given {@code long} value is the range of signed int values.
  77      */
  78     public static boolean isInt(long l) {
  79         return (int) l == l;
  80     }
  81 
  82     /**
  83      * Determines if a given {@code int} value is the range of signed short values.
  84      */
  85     public static boolean isShort(int x) {
  86         return (short) x == x;
  87     }
  88 
  89     /**
  90      * Determines if a given {@code long} value is the range of signed short values.
  91      */
  92     public static boolean isShort(long x) {
  93         return (short) x == x;
  94     }
  95 
  96     public static boolean isUShort(int s) {
  97         return s == (s & 0xFFFF);
  98     }
  99 
 100     public static boolean isUShort(long s) {
 101         return s == (s & 0xFFFF);
 102     }
 103 
 104     public static boolean is32bit(long x) {
 105         return -0x80000000L <= x && x < 0x80000000L;
 106     }
 107 
 108     public static short safeToShort(int v) {
 109         assert isShort(v);
 110         return (short) v;
 111     }
 112 
 113     public static int safeToInt(long v) {
 114         assert isInt(v);
 115         return (int) v;
 116     }
 117 
 118     public static int roundUp(int number, int mod) {
 119         return ((number + mod - 1) / mod) * mod;
 120     }
 121 
 122     public static long roundUp(long number, long mod) {
 123         return ((number + mod - 1L) / mod) * mod;
 124     }
 125 
 126     public static int roundDown(int number, int mod) {
 127         return number / mod * mod;
 128     }
 129 
 130     public static long roundDown(long number, long mod) {
 131         return number / mod * mod;
 132     }
 133 
 134     public static int log2Ceil(int val) {
 135         int x = 1;
 136         int log2 = 0;
 137         while (x < val) {
 138             log2++;
 139             x *= 2;
 140         }
 141         return log2;
 142     }
 143 
 144     public static boolean isUnsignedNbit(int n, int value) {
 145         assert n > 0 && n < 32;
 146         return 32 - Integer.numberOfLeadingZeros(value) <= n;
 147     }
 148 
 149     public static boolean isUnsignedNbit(int n, long value) {
 150         assert n > 0 && n < 64;
 151         return 64 - Long.numberOfLeadingZeros(value) <= n;
 152     }
 153 
 154     public static boolean isSignedNbit(int n, int value) {
 155         assert n > 0 && n < 32;
 156         int min = -(1 << (n - 1));
 157         int max = (1 << (n - 1)) - 1;
 158         return value >= min && value <= max;
 159     }
 160 
 161     public static boolean isSignedNbit(int n, long value) {
 162         assert n > 0 && n < 64;
 163         long min = -(1L << (n - 1));
 164         long max = (1L << (n - 1)) - 1;
 165         return value >= min && value <= max;
 166     }
 167 
 168     /**
 169      *
 170      * @param n Number of bits that should be set to 1. Must be between 0 and 32 (inclusive).
 171      * @return A number with n bits set to 1.
 172      */
 173     public static int getNbitNumberInt(int n) {
 174         assert n >= 0 && n <= 32 : "0 <= n <= 32; instead: " + n;
 175         if (n < 32) {
 176             return (1 << n) - 1;
 177         } else {
 178             return 0xFFFFFFFF;
 179         }
 180     }
 181 
 182     /**
 183      *
 184      * @param n Number of bits that should be set to 1. Must be between 0 and 64 (inclusive).
 185      * @return A number with n bits set to 1.
 186      */
 187     public static long getNbitNumberLong(int n) {
 188         assert n >= 0 && n <= 64;
 189         if (n < 64) {
 190             return (1L << n) - 1;
 191         } else {
 192             return 0xFFFFFFFFFFFFFFFFL;
 193         }
 194     }
 195 
 196     /**
 197      * Get the minimum value representable in a {@code bits} bit signed integer.
 198      */
 199     public static long minValue(int bits) {
 200         return CodeUtil.minValue(bits);
 201     }
 202 
 203     /**
 204      * Get the maximum value representable in a {@code bits} bit signed integer.
 205      */
 206     public static long maxValue(int bits) {
 207         return CodeUtil.maxValue(bits);
 208     }
 209 
 210     /**
 211      * Get the maximum value representable in a {@code bits} bit unsigned integer.
 212      */
 213     public static long maxValueUnsigned(int bits) {
 214         return getNbitNumberLong(bits);
 215     }
 216 
 217     public static long maxUnsigned(long a, long b) {
 218         if (Long.compareUnsigned(a, b) < 0) {
 219             return b;
 220         }
 221         return a;
 222     }
 223 
 224     public static long minUnsigned(long a, long b) {
 225         if (Long.compareUnsigned(a, b) < 0) {
 226             return a;
 227         }
 228         return b;
 229     }
 230 
 231     public static boolean sameSign(long a, long b) {
 232         return a < 0 == b < 0;
 233     }
 234 }
--- EOF ---