hotspot/test/compiler/aot/AotCompiler.java
changeset 46826 dae7992b1615
parent 43479 67507b173e81
child 46980 28e20e703392
equal deleted inserted replaced
46824:9e13f4eb7670 46826:dae7992b1615
    21  * questions.
    21  * questions.
    22  */
    22  */
    23 
    23 
    24 package compiler.aot;
    24 package compiler.aot;
    25 
    25 
       
    26 import jdk.test.lib.Platform;
       
    27 import jdk.test.lib.artifacts.Artifact;
       
    28 import jdk.test.lib.artifacts.ArtifactResolver;
    26 import jdk.test.lib.process.OutputAnalyzer;
    29 import jdk.test.lib.process.OutputAnalyzer;
    27 import java.io.File;
    30 import java.io.File;
       
    31 import java.io.FileNotFoundException;
    28 import java.io.IOException;
    32 import java.io.IOException;
       
    33 import java.lang.annotation.Annotation;
    29 import java.nio.file.Files;
    34 import java.nio.file.Files;
    30 import java.nio.file.Path;
    35 import java.nio.file.Path;
    31 import java.nio.file.Paths;
    36 import java.nio.file.Paths;
    32 import java.nio.file.StandardOpenOption;
    37 import java.nio.file.StandardOpenOption;
    33 import java.util.ArrayList;
    38 import java.util.ArrayList;
    34 import java.util.Arrays;
    39 import java.util.Arrays;
    35 import java.util.List;
    40 import java.util.List;
    36 import jdk.test.lib.JDKToolLauncher;
    41 import jdk.test.lib.JDKToolLauncher;
    37 import jdk.test.lib.Utils;
    42 import jdk.test.lib.Utils;
       
    43 import jdk.test.lib.process.ProcessTools;
    38 
    44 
    39 /**
    45 /**
    40  * A simple class calling AOT compiler over requested items
    46  * A simple class calling AOT compiler over requested items
    41  */
    47  */
    42 public class AotCompiler {
    48 public class AotCompiler {
   100             args.add("--compile-commands");
   106             args.add("--compile-commands");
   101             args.add(file.toString());
   107             args.add(file.toString());
   102         }
   108         }
   103         args.add("--class-name");
   109         args.add("--class-name");
   104         args.add(item);
   110         args.add(item);
       
   111         String linker = resolveLinker();
       
   112         if (linker != null) {
       
   113             args.add("--linker-path");
       
   114             args.add(linker);
       
   115         }
   105         return launchJaotc(args, extraopts);
   116         return launchJaotc(args, extraopts);
   106     }
   117     }
   107 
   118 
   108     private static OutputAnalyzer launchJaotc(List<String> args, List<String> extraVmOpts) {
   119     private static OutputAnalyzer launchJaotc(List<String> args, List<String> extraVmOpts) {
   109         JDKToolLauncher launcher = JDKToolLauncher.createUsingTestJDK("jaotc");
   120         JDKToolLauncher launcher = JDKToolLauncher.createUsingTestJDK("jaotc");
   117         }
   128         }
   118         for (String arg : args) {
   129         for (String arg : args) {
   119             launcher.addToolArg(arg);
   130             launcher.addToolArg(arg);
   120         }
   131         }
   121         try {
   132         try {
   122             return new OutputAnalyzer(new ProcessBuilder(launcher.getCommand()).inheritIO().start());
   133             return ProcessTools.executeCommand(new ProcessBuilder(launcher.getCommand()).redirectErrorStream(true));
   123         } catch (IOException e) {
   134         } catch (Throwable e) {
   124             throw new Error("Can't start test process: " + e, e);
   135             throw new Error("Can't start test process: " + e, e);
   125         }
   136         }
   126     }
   137     }
   127 
   138 
   128     public static void printUsage() {
   139     public static void printUsage() {
   129         System.err.println("Usage: " + AotCompiler.class.getName()
   140         System.err.println("Usage: " + AotCompiler.class.getName()
   130                 + " -class <class> -libname <.so name>"
   141                 + " -class <class> -libname <.so name>"
   131                 + " [-compile <compileItems>]* [-extraopt <java option>]*");
   142                 + " [-compile <compileItems>]* [-extraopt <java option>]*");
   132     }
   143     }
       
   144 
       
   145     public static String resolveLinker() {
       
   146         Path linker = null;
       
   147         // 1st, check if PATH has ld
       
   148         for (String path : System.getenv("PATH").split(File.pathSeparator)) {
       
   149             if (Files.exists(Paths.get(path).resolve("ld"))) {
       
   150                 // there is ld in PATH, jaotc is supposed to find it by its own
       
   151                 return null;
       
   152             }
       
   153         }
       
   154         // there is no ld in PATH, will use ld from devkit
       
   155         // artifacts are got from common/conf/jib-profiles.js
       
   156         try {
       
   157             if (Platform.isWindows()) {
       
   158                 if (Platform.isX64()) {
       
   159                     @Artifact(organization = "jpg.infra.builddeps",
       
   160                             name = "devkit-windows_x64",
       
   161                             revision = "VS2013SP4+1.0",
       
   162                             extension = "tar.gz")
       
   163                     class DevkitWindowsX64 { }
       
   164                     String artifactName = "jpg.infra.builddeps."
       
   165                             + "devkit-windows_x64-"
       
   166                             + "VS2013SP4+1.0";
       
   167                     Path devkit = ArtifactResolver.resolve(DevkitWindowsX64.class)
       
   168                                                   .get(artifactName);
       
   169                     linker = devkit.resolve("VC")
       
   170                                    .resolve("bin")
       
   171                                    .resolve("amd64")
       
   172                                    .resolve("link.exe");
       
   173                 }
       
   174             } else if (Platform.isOSX()) {
       
   175                 @Artifact(organization =  "jpg.infra.builddeps",
       
   176                         name = "devkit-macosx_x64",
       
   177                         revision = "Xcode6.3-MacOSX10.9+1.0",
       
   178                         extension = "tar.gz")
       
   179                 class DevkitMacosx { }
       
   180                 String artifactName = "jpg.infra.builddeps."
       
   181                         + "devkit-macosx_x64-"
       
   182                         + "Xcode6.3-MacOSX10.9+1.0";
       
   183                 Path devkit = ArtifactResolver.resolve(DevkitMacosx.class)
       
   184                                               .get(artifactName);
       
   185                 linker = devkit.resolve("Xcode.app")
       
   186                                .resolve("Contents")
       
   187                                .resolve("Developer")
       
   188                                .resolve("Toolchains")
       
   189                                .resolve("XcodeDefault.xctoolchain")
       
   190                                .resolve("usr")
       
   191                                .resolve("bin")
       
   192                                .resolve("ld");
       
   193             } else if (Platform.isSolaris()) {
       
   194                 if (Platform.isSparc()) {
       
   195                     @Artifact(organization =  "jpg.infra.builddeps",
       
   196                             name = "devkit-solaris_sparcv9",
       
   197                             revision = "SS12u4-Solaris11u1+1.0",
       
   198                             extension = "tar.gz")
       
   199                     class DevkitSolarisSparc { }
       
   200 
       
   201                     String artifactName = "jpg.infra.builddeps."
       
   202                             + "devkit-solaris_sparcv9-"
       
   203                             + "SS12u4-Solaris11u1+1.0";
       
   204                     Path devkit = ArtifactResolver.resolve(DevkitSolarisSparc.class)
       
   205                                                   .get(artifactName);
       
   206                     linker = devkit.resolve("SS12u4-Solaris11u1")
       
   207                                    .resolve("gnu")
       
   208                                    .resolve("bin")
       
   209                                    .resolve("ld");
       
   210                 } else if (Platform.isX64()) {
       
   211                     @Artifact(organization =  "jpg.infra.builddeps",
       
   212                             name = "devkit-solaris_x64",
       
   213                             revision = "SS12u4-Solaris11u1+1.0",
       
   214                             extension = "tar.gz")
       
   215                     class DevkitSolarisX64 { }
       
   216 
       
   217                     String artifactName = "jpg.infra.builddeps."
       
   218                             + "devkit-solaris_x64-"
       
   219                             + "SS12u4-Solaris11u1+1.0";
       
   220                     Path devkit = ArtifactResolver.resolve(DevkitSolarisX64.class)
       
   221                                                   .get(artifactName);
       
   222                     linker = devkit.resolve("SS12u4-Solaris11u1")
       
   223                                    .resolve("bin")
       
   224                                    .resolve("amd64")
       
   225                                    .resolve("ld");
       
   226                 }
       
   227             } else if (Platform.isLinux()) {
       
   228                 if (Platform.isAArch64()) {
       
   229                     @Artifact(organization = "jpg.infra.builddeps",
       
   230                             name = "devkit-linux_aarch64",
       
   231                             revision = "gcc-linaro-aarch64-linux-gnu-4.8-2013.11_linux+1.0",
       
   232                             extension = "tar.gz")
       
   233                     class DevkitLinuxAArch64 { }
       
   234 
       
   235                     String artifactName = "jpg.infra.builddeps."
       
   236                             + "devkit-linux_aarch64-"
       
   237                             + "gcc-linaro-aarch64-linux-gnu-4.8-2013.11_linux+1.0";
       
   238                     Path devkit = ArtifactResolver.resolve(DevkitLinuxAArch64.class)
       
   239                                                   .get(artifactName);
       
   240                     linker = devkit.resolve("aarch64-linux-gnu")
       
   241                                    .resolve("bin")
       
   242                                    .resolve("ld");
       
   243                 } else if (Platform.isARM()) {
       
   244                     @Artifact(organization = "jpg.infra.builddeps",
       
   245                             name = "devkit-linux_arm",
       
   246                             revision = "gcc-linaro-arm-linux-gnueabihf-raspbian-2012.09-20120921_linux+1.0",
       
   247                             extension = "tar.gz")
       
   248                     class DevkitLinuxARM { }
       
   249 
       
   250                     String artifactName = "jpg.infra.builddeps."
       
   251                             + "devkit-linux_arm-"
       
   252                             + "gcc-linaro-arm-linux-gnueabihf-raspbian-2012.09-20120921_linux+1.0";
       
   253                     Path devkit = ArtifactResolver.resolve(DevkitLinuxARM.class)
       
   254                                                   .get(artifactName);
       
   255                     linker = devkit.resolve("arm-linux-gnueabihf")
       
   256                                    .resolve("bin")
       
   257                                    .resolve("ld");
       
   258                 } else if (Platform.isX64()) {
       
   259                     @Artifact(organization = "jpg.infra.builddeps",
       
   260                             name = "devkit-linux_x64",
       
   261                             revision = "gcc4.9.2-OEL6.4+1.1",
       
   262                             extension = "tar.gz")
       
   263                     class DevkitLinuxX64 { }
       
   264 
       
   265                     String artifactName = "jpg.infra.builddeps."
       
   266                             + "devkit-linux_x64-"
       
   267                             + "gcc4.9.2-OEL6.4+1.1";
       
   268                     Path devkit = ArtifactResolver.resolve(DevkitLinuxX64.class)
       
   269                                                   .get(artifactName);
       
   270                     linker = devkit.resolve("bin")
       
   271                                    .resolve("ld");
       
   272                 }
       
   273             }
       
   274         } catch (FileNotFoundException e) {
       
   275             throw new Error("artifact resolution error: " + e, e);
       
   276         }
       
   277         if (linker != null) {
       
   278             return linker.toAbsolutePath().toString();
       
   279         }
       
   280         return null;
       
   281     }
   133 }
   282 }