Mercurial > jdk8-mips64-public > hotspot / file revision

 /*

  * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  *

  */

 import com.oracle.java.testlibrary.Asserts;

 import com.oracle.java.testlibrary.Platform;

 import com.oracle.java.testlibrary.Utils;

 import sun.hotspot.code.NMethod;

 import sun.hotspot.cpuinfo.CPUInfo;

 import java.lang.reflect.Executable;

 import java.lang.reflect.Method;

 import java.util.concurrent.Callable;

 import java.util.function.Function;

 public class BmiIntrinsicBase extends CompilerWhiteBoxTest {

     protected BmiIntrinsicBase(BmiTestCase testCase) {

         super(testCase);

     }

     public static void verifyTestCase(Function<Method, BmiTestCase> constructor, Method... methods) throws Exception {

         for (Method method : methods) {

             new BmiIntrinsicBase(constructor.apply(method)).test();

         }

     }

     @Override

     protected void test() throws Exception {

         BmiTestCase bmiTestCase = (BmiTestCase) testCase;

         if (!(Platform.isX86() || Platform.isX64())) {

             System.out.println("Unsupported platform, test SKIPPED");

             return;

         }

         if (!Platform.isServer()) {

             System.out.println("Not server VM, test SKIPPED");

             return;

         }

         if (!CPUInfo.hasFeature(bmiTestCase.getCpuFlag())) {

             System.out.println("Unsupported hardware, no required CPU flag " + bmiTestCase.getCpuFlag() + " , test SKIPPED");

             return;

         }

         if (!Boolean.valueOf(getVMOption(bmiTestCase.getVMFlag()))) {

             System.out.println("VM flag " + bmiTestCase.getVMFlag() + " disabled, test SKIPPED");

             return;

         }

         System.out.println(testCase.name());

         switch (MODE) {

             case "compiled mode":

             case "mixed mode":

                 if (TIERED_COMPILATION && TIERED_STOP_AT_LEVEL != CompilerWhiteBoxTest.COMP_LEVEL_MAX) {

                     System.out.println("TieredStopAtLevel value (" + TIERED_STOP_AT_LEVEL + ") is too low, test SKIPPED");

                     return;

                 }

                 deoptimize();

                 compileAtLevelAndCheck(CompilerWhiteBoxTest.COMP_LEVEL_MAX);

                 break;

             case "interpreted mode": // test is not applicable in this mode;

                 System.err.println("Warning: This test is not applicable in mode: " + MODE);

                 break;

             default:

                 throw new AssertionError("Test bug, unknown VM mode: " + MODE);

         }

     }

     protected void compileAtLevelAndCheck(int level) {

         WHITE_BOX.enqueueMethodForCompilation(method, level);

         waitBackgroundCompilation();

         checkCompilation(method, level);

         checkEmittedCode(method);

     }

     protected void checkCompilation(Executable executable, int level) {

         if (!WHITE_BOX.isMethodCompiled(executable)) {

             throw new AssertionError("Test bug, expected compilation (level): " + level + ", but not compiled" + WHITE_BOX.isMethodCompilable(executable, level));

         }

         final int compilationLevel = WHITE_BOX.getMethodCompilationLevel(executable);

         if (compilationLevel != level) {

             throw new AssertionError("Test bug, expected compilation (level): " + level + ", but level: " + compilationLevel);

         }

     }

     protected void checkEmittedCode(Executable executable) {

         final byte[] nativeCode = NMethod.get(executable, false).insts;

         if (!((BmiTestCase) testCase).verifyPositive(nativeCode)) {

             throw new AssertionError(testCase.name() + "CPU instructions expected not found: " + Utils.toHexString(nativeCode));

         } else {

             System.out.println("CPU instructions found, PASSED");

         }

     }

     abstract static class BmiTestCase implements CompilerWhiteBoxTest.TestCase {

         private final Method method;

         protected byte[] instrMask;

         protected byte[] instrPattern;

         protected boolean isLongOperation;

         public BmiTestCase(Method method) {

             this.method = method;

         }

         @Override

         public String name() {

             return method.toGenericString();

         }

         @Override

         public Executable getExecutable() {

             return method;

         }

         @Override

         public Callable<Integer> getCallable() {

             return null;

         }

         @Override

         public boolean isOsr() {

             return false;

         }

         protected int countCpuInstructions(byte[] nativeCode) {

             int count = 0;

             int patternSize = Math.min(instrMask.length, instrPattern.length);

             boolean found;

             Asserts.assertGreaterThan(patternSize, 0);

             for (int i = 0, n = nativeCode.length - patternSize; i < n; i++) {

                 found = true;

                 for (int j = 0; j < patternSize; j++) {

                     if ((nativeCode[i + j] & instrMask[j]) != instrPattern[j]) {

                         found = false;

                         break;

                     }

                 }

                 if (found) {

                     ++count;

                     i += patternSize - 1;

                 }

             }

             return count;

         }

         public boolean verifyPositive(byte[] nativeCode) {

             final int cnt = countCpuInstructions(nativeCode);

             if (Platform.isX86()) {

                 return cnt >= (isLongOperation ? 2 : 1);

             } else {

                 return Platform.isX64() && cnt >= 1;

             }

         }

         protected String getCpuFlag() {

             return "bmi1";

         }

         protected String getVMFlag() {

             return "UseBMI1Instructions";

         }

     }

 }