1 /*
2  * Copyright (c) 2011, 2018, 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 
isShiftCount(int x)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      */
isUByte(int x)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      */
isByte(int x)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      */
isUByte(long x)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      */
isByte(long l)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      */
isUInt(long x)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      */
isInt(long l)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      */
isShort(int x)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      */
isShort(long x)92     public static boolean isShort(long x) {
93         return (short) x == x;
94     }
95 
isUShort(int s)96     public static boolean isUShort(int s) {
97         return s == (s & 0xFFFF);
98     }
99 
isUShort(long s)100     public static boolean isUShort(long s) {
101         return s == (s & 0xFFFF);
102     }
103 
is32bit(long x)104     public static boolean is32bit(long x) {
105         return -0x80000000L <= x && x < 0x80000000L;
106     }
107 
safeToShort(int v)108     public static short safeToShort(int v) {
109         assert isShort(v);
110         return (short) v;
111     }
112 
safeToInt(long v)113     public static int safeToInt(long v) {
114         assert isInt(v);
115         return (int) v;
116     }
117 
roundUp(int number, int mod)118     public static int roundUp(int number, int mod) {
119         return ((number + mod - 1) / mod) * mod;
120     }
121 
roundUp(long number, long mod)122     public static long roundUp(long number, long mod) {
123         return ((number + mod - 1L) / mod) * mod;
124     }
125 
roundDown(int number, int mod)126     public static int roundDown(int number, int mod) {
127         return number / mod * mod;
128     }
129 
roundDown(long number, long mod)130     public static long roundDown(long number, long mod) {
131         return number / mod * mod;
132     }
133 
log2Ceil(int val)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 
isUnsignedNbit(int n, int value)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 }
235