1 /*
  2  * Copyright (c) 2020, 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.  Oracle designates this
  8  * particular file as subject to the "Classpath" exception as provided
  9  * by Oracle in the LICENSE file that accompanied this code.
 10  *
 11  * This code is distributed in the hope that it will be useful, but WITHOUT
 12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 14  * version 2 for more details (a copy is included in the LICENSE file that
 15  * accompanied this code).
 16  *
 17  * You should have received a copy of the GNU General Public License version
 18  * 2 along with this work; if not, write to the Free Software Foundation,
 19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 20  *
 21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 22  * or visit www.oracle.com if you need additional information or have any
 23  * questions.
 24  */
 25 package jdk.incubator.vector;
 26 
 27 import jdk.internal.vm.annotation.ForceInline;
 28 
 29 import java.util.Objects;
 30 
 31 /*non-public*/ class VectorIntrinsics {
 32     static final int VECTOR_ACCESS_OOB_CHECK = Integer.getInteger("jdk.incubator.vector.VECTOR_ACCESS_OOB_CHECK", 2);
 33 
 34     @ForceInline
 35     static void requireLength(int haveLength, int length) {
 36         if (haveLength != length) {
 37             throw requireLengthFailed(haveLength, length);
 38         }
 39     }
 40     static IllegalArgumentException requireLengthFailed(int haveLength, int length) {
 41         String msg = String.format("Length check failed: "+
 42                                    "length %d should have been %s",
 43                                    haveLength, length);
 44         return new IllegalArgumentException(msg);
 45     }
 46 
 47     @ForceInline
 48     static int checkFromIndexSize(int ix, int vlen, int length) {
 49         switch (VectorIntrinsics.VECTOR_ACCESS_OOB_CHECK) {
 50             case 0: return ix; // no range check
 51             case 1: return Objects.checkFromIndexSize(ix, vlen, length);
 52             case 2: return Objects.checkIndex(ix, length - (vlen - 1));
 53             default: throw new InternalError();
 54         }
 55     }
 56 
 57     @ForceInline
 58     static IntVector checkIndex(IntVector vix, int length) {
 59         switch (VectorIntrinsics.VECTOR_ACCESS_OOB_CHECK) {
 60             case 0: return vix; // no range check
 61             case 1: // fall-through
 62             case 2:
 63                 if (vix.compare(VectorOperators.LT, 0)
 64                     .or(vix.compare(VectorOperators.GE, length))
 65                     .anyTrue()) {
 66                     throw checkIndexFailed(vix, length);
 67                 }
 68                 return vix;
 69             default: throw new InternalError();
 70         }
 71     }
 72 
 73     private static
 74     IndexOutOfBoundsException checkIndexFailed(IntVector vix, int length) {
 75         String msg = String.format("Range check failed: vector %s out of bounds for length %d", vix, length);
 76         return new IndexOutOfBoundsException(msg);
 77     }
 78 
 79     // If the index is not already a multiple of size,
 80     // round it down to the next smaller multiple of size.
 81     // It is an error if size is less than zero.
 82     @ForceInline
 83     static int roundDown(int index, int size) {
 84         if ((size & (size - 1)) == 0) {
 85             // Size is zero or a power of two, so we got this.
 86             return index & ~(size - 1);
 87         } else {
 88             return roundDownNPOT(index, size);
 89         }
 90     }
 91     private static int roundDownNPOT(int index, int size) {
 92         if (index >= 0) {
 93             return index - (index % size);
 94         } else {
 95             return index - Math.floorMod(index, Math.abs(size));
 96         }
 97     }
 98     @ForceInline
 99     static int wrapToRange(int index, int size) {
100         if ((size & (size - 1)) == 0) {
101             // Size is zero or a power of two, so we got this.
102             return index & (size - 1);
103         } else {
104             return wrapToRangeNPOT(index, size);
105         }
106     }
107     private static int wrapToRangeNPOT(int index, int size) {
108         if (index >= 0) {
109             return (index % size);
110         } else {
111             return Math.floorMod(index, Math.abs(size));
112         }
113     }
114 }