diff --git a/java/compiler/impl/src/com/intellij/compiler/CompilerManagerImpl.java b/java/compiler/impl/src/com/intellij/compiler/CompilerManagerImpl.java
index 1876f91ab744..52c2688a17b6 100644
--- a/java/compiler/impl/src/com/intellij/compiler/CompilerManagerImpl.java
+++ b/java/compiler/impl/src/com/intellij/compiler/CompilerManagerImpl.java
@@ -37,6 +37,7 @@ import com.intellij.openapi.projectRoots.SdkTypeId;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.profile.codeInspection.InspectionProjectProfileManager;
@@ -346,13 +347,15 @@ public class CompilerManagerImpl extends CompilerManager {
 
     final Pair<Sdk, JavaSdkVersion> runtime = BuildManager.getJavacRuntimeSdk(myProject);
 
-    String javaHome = null;
+    String javaPath = null;
+    String toolsPath = null;
     final Sdk sdk = runtime.getFirst();
     final SdkTypeId type = sdk.getSdkType();
     if (type instanceof JavaSdkType) {
-      javaHome = sdk.getHomePath();
+      javaPath = StringUtil.nullize(((JavaSdkType)type).getVMExecutablePath(sdk), true);
+      toolsPath = StringUtil.nullize(((JavaSdkType)type).getToolsPath(sdk), true);
     }
-    if (javaHome == null) {
+    if (javaPath == null) {
       throw new IOException("Was not able to determine JDK for project " + myProject.getName());
     }
 
@@ -377,7 +380,7 @@ public class CompilerManagerImpl extends CompilerManager {
 
     final ExternalJavacManager javacManager = getJavacManager();
     boolean compiledOk = javacManager != null && javacManager.forkJavac(
-      javaHome, -1, Collections.emptyList(), options, platformCp, classpath, modulePath, sourcePath, files, outs, diagnostic, outputCollector,
+      javaPath, toolsPath, -1, Collections.emptyList(), options, platformCp, classpath, modulePath, sourcePath, files, outs, diagnostic, outputCollector,
       new JavacCompilerTool(), CanceledStatus.NULL
     );
 
diff --git a/jps/jps-builders/src/org/jetbrains/jps/cmdline/ClasspathBootstrap.java b/jps/jps-builders/src/org/jetbrains/jps/cmdline/ClasspathBootstrap.java
index 17b6a47702bf..5e4877fcdab6 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/cmdline/ClasspathBootstrap.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/cmdline/ClasspathBootstrap.java
@@ -172,7 +172,7 @@ public class ClasspathBootstrap {
     }
   }
 
-  public static List<File> getExternalJavacProcessClasspath(String sdkHome, JavaCompilingTool compilingTool) {
+  public static List<File> getExternalJavacProcessClasspath(String javaPath, String toolsPath, JavaCompilingTool compilingTool) {
     final Set<File> cp = new LinkedHashSet<File>();
     cp.add(getResourceFile(ExternalJavacProcess.class)); // self
     // util
@@ -208,8 +208,8 @@ public class ClasspathBootstrap {
     try {
       final String localJavaHome = FileUtil.toSystemIndependentName(SystemProperties.getJavaHome());
       // sdkHome is not the same as the sdk used to run this process
-      final File candidate = new File(sdkHome, "lib/tools.jar");
-      if (candidate.exists()) {
+      File candidate = toolsPath == null ? null : new File(toolsPath);
+      if (candidate != null && candidate.exists()) {
         cp.add(candidate);
       }
       else {
@@ -223,7 +223,8 @@ public class ClasspathBootstrap {
               relPath = FileUtil.getRelativePath(FileUtil.toSystemIndependentName(new File(localJavaHome).getParent()), localJarPath, '/');
             }
             if (relPath != null) {
-              final File targetFile = new File(sdkHome, relPath);
+              File javaHome = new File(javaPath).getParentFile().getParentFile();
+              File targetFile = new File(javaHome, relPath);
               cp.add(targetFile);  // tools.jar
             }
           }
diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/java/JavaBuilder.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/java/JavaBuilder.java
index 864e29d5e4f2..6c08d6879106 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/incremental/java/JavaBuilder.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/java/JavaBuilder.java
@@ -469,8 +469,9 @@ public class JavaBuilder extends ModuleLevelBuilder {
         final List<String> vmOptions = getCompilationVMOptions(context, compilingTool);
         final ExternalJavacManager server = ensureJavacServerStarted(context);
         rc = server.forkJavac(
-          forkSdk.getFirst(), 
-          getExternalJavacHeapSize(context), 
+          forkSdk.getFirst() + "/bin/java",
+          forkSdk.getFirst() + "/lib/tools.jar",
+          getExternalJavacHeapSize(context),
           vmOptions, options, platformCp, classPath, modulePath, sourcePath,
           files, outs, diagnosticSink, classesConsumer, compilingTool, context.getCancelStatus()
         );
diff --git a/jps/jps-builders/src/org/jetbrains/jps/javac/ExternalJavacManager.java b/jps/jps-builders/src/org/jetbrains/jps/javac/ExternalJavacManager.java
index afaf2dd0373f..a43b84ca7834 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/javac/ExternalJavacManager.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/javac/ExternalJavacManager.java
@@ -109,7 +109,8 @@ public class ExternalJavacManager {
   }
   
 
-  public boolean forkJavac(final String javaHome, final int heapSize, List<String> vmOptions, List<String> options,
+  public boolean forkJavac(String javaPath, String toolsPath,
+                           int heapSize, List<String> vmOptions, List<String> options,
                            Collection<File> platformCp,
                            Collection<File> classpath,
                            Collection<File> modulePath,
@@ -128,7 +129,7 @@ public class ExternalJavacManager {
     }
     try {
       final ExternalJavacProcessHandler processHandler = launchExternalJavacProcess(
-        uuid, javaHome, heapSize, myListenPort, myWorkingDir, vmOptions, compilingTool
+        uuid, javaPath, toolsPath, heapSize, myListenPort, myWorkingDir, vmOptions, compilingTool
       );
       processHandler.addProcessListener(new ProcessAdapter() {
         public void onTextAvailable(ProcessEvent event, Key outputType) {
@@ -200,14 +201,15 @@ public class ExternalJavacManager {
     myChannelRegistrar.close().awaitUninterruptibly();
   }
 
-  private ExternalJavacProcessHandler launchExternalJavacProcess(UUID uuid, String sdkHomePath,
-                                                                        int heapSize,
-                                                                        int port,
-                                                                        File workingDir,
-                                                                        List<String> vmOptions,
-                                                                        JavaCompilingTool compilingTool) throws Exception {
+  private ExternalJavacProcessHandler launchExternalJavacProcess(UUID uuid,
+                                                                 String javaPath, String toolsPath,
+                                                                 int heapSize,
+                                                                 int port,
+                                                                 File workingDir,
+                                                                 List<String> vmOptions,
+                                                                 JavaCompilingTool compilingTool) throws Exception {
     final List<String> cmdLine = new ArrayList<String>();
-    appendParam(cmdLine, getVMExecutablePath(sdkHomePath));
+    appendParam(cmdLine, javaPath);
     //appendParam(cmdLine, "-XX:MaxPermSize=150m");
     //appendParam(cmdLine, "-XX:ReservedCodeCacheSize=64m");
     appendParam(cmdLine, "-Djava.awt.headless=true");
@@ -259,7 +261,7 @@ public class ExternalJavacManager {
 
     appendParam(cmdLine, "-classpath");
 
-    final List<File> cp = ClasspathBootstrap.getExternalJavacProcessClasspath(sdkHomePath, compilingTool);
+    final List<File> cp = ClasspathBootstrap.getExternalJavacProcessClasspath(javaPath, toolsPath, compilingTool);
     final StringBuilder classpath = new StringBuilder();
     for (File file : cp) {
       if (classpath.length() > 0) {
@@ -301,10 +303,6 @@ public class ExternalJavacManager {
     cmdLine.add(param);
   }
 
-  private static String getVMExecutablePath(String sdkHome) {
-    return sdkHome + "/bin/java";
-  }
-
   protected static class ExternalJavacProcessHandler extends BaseOSProcessHandler {
     private volatile int myExitCode;