diff --git a/dev/core/src/com/google/gwt/dev/Compiler.java b/dev/core/src/com/google/gwt/dev/Compiler.java
index 385baca..9de717c 100644
--- a/dev/core/src/com/google/gwt/dev/Compiler.java
+++ b/dev/core/src/com/google/gwt/dev/Compiler.java
@@ -188,6 +188,8 @@
           TreeLogger branch = logger.branch(TreeLogger.INFO,
               "Compiling module " + moduleName);
 
+          // Optimize early since permutation compiles will run in process.
+          options.setOptimizePrecompile(true);
           Precompilation precompilation = Precompile.precompile(branch,
               options, module, options.getGenDir(), compilerWorkDir,
               options.getDumpSignatureFile());
diff --git a/dev/core/src/com/google/gwt/dev/GWTCompiler.java b/dev/core/src/com/google/gwt/dev/GWTCompiler.java
index 4a1cc19..9f90509 100644
--- a/dev/core/src/com/google/gwt/dev/GWTCompiler.java
+++ b/dev/core/src/com/google/gwt/dev/GWTCompiler.java
@@ -181,6 +181,8 @@
           logger = logger.branch(TreeLogger.INFO, "Compiling module "
               + moduleName);
 
+          // Optimize early since permutation compiles will run in process.
+          options.setOptimizePrecompile(true);
           Precompilation precompilation = Precompile.precompile(logger,
               options, module, options.getGenDir(), compilerWorkDir,
               options.getDumpSignatureFile());
diff --git a/dev/core/src/com/google/gwt/dev/Precompile.java b/dev/core/src/com/google/gwt/dev/Precompile.java
index 2344216..5c28b9e 100644
--- a/dev/core/src/com/google/gwt/dev/Precompile.java
+++ b/dev/core/src/com/google/gwt/dev/Precompile.java
@@ -180,6 +180,10 @@
       return jjsOptions.isEnableAssertions();
     }
 
+    public boolean isOptimizePrecompile() {
+      return jjsOptions.isOptimizePrecompile();
+    }
+
     public boolean isRunAsyncEnabled() {
       return jjsOptions.isRunAsyncEnabled();
     }
@@ -236,6 +240,10 @@
       this.maxPermsPerPrecompile = maxPermsPerPrecompile;
     }
 
+    public void setOptimizePrecompile(boolean optimize) {
+      jjsOptions.setOptimizePrecompile(optimize);
+    }
+
     public void setOutput(JsOutputOption output) {
       jjsOptions.setOutput(output);
     }
@@ -427,6 +435,8 @@
           module, compilationState, generatorArtifacts,
           new PropertyPermutations(module.getProperties()), genDir,
           generatorResourcesDir);
+      // Never optimize on a validation run.
+      jjsOptions.setOptimizePrecompile(false);
       JavaToJavaScriptCompiler.precompile(logger, module, rpo, declEntryPts,
           additionalRootTypes, jjsOptions, true);
       return true;
@@ -500,6 +510,8 @@
 
   public boolean run(TreeLogger logger) throws UnableToCompleteException {
     boolean originalCompilationStateRetained = options.isCompilationStateRetained();
+    // Avoid early optimizations since permutation compiles will run separately.
+    options.setOptimizePrecompile(false);
 
     for (String moduleName : options.getModuleNames()) {
       File compilerWorkDir = options.getCompilerWorkDir(moduleName);
diff --git a/dev/core/src/com/google/gwt/dev/jjs/JJSOptions.java b/dev/core/src/com/google/gwt/dev/jjs/JJSOptions.java
index 9ca8436..f9ff12c 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/JJSOptions.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/JJSOptions.java
@@ -21,6 +21,7 @@
 import com.google.gwt.dev.util.arg.OptionDisableClassMetadata;
 import com.google.gwt.dev.util.arg.OptionDraftCompile;
 import com.google.gwt.dev.util.arg.OptionEnableAssertions;
+import com.google.gwt.dev.util.arg.OptionOptimizePrecompile;
 import com.google.gwt.dev.util.arg.OptionRunAsyncEnabled;
 import com.google.gwt.dev.util.arg.OptionScriptStyle;
 import com.google.gwt.dev.util.arg.OptionSoycEnabled;
@@ -31,5 +32,5 @@
 public interface JJSOptions extends OptionAggressivelyOptimize,
     OptionDisableClassMetadata, OptionDisableCastChecking, OptionDraftCompile,
     OptionEnableAssertions, OptionRunAsyncEnabled, OptionScriptStyle,
-    OptionSoycEnabled, OptionCompilationStateRetained {
+    OptionSoycEnabled, OptionCompilationStateRetained, OptionOptimizePrecompile {
 }
diff --git a/dev/core/src/com/google/gwt/dev/jjs/JJSOptionsImpl.java b/dev/core/src/com/google/gwt/dev/jjs/JJSOptionsImpl.java
index 569e1ad..80c49f5 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/JJSOptionsImpl.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/JJSOptionsImpl.java
@@ -28,6 +28,7 @@
   private boolean disableClassMetadata = false;
   private boolean draftCompile = false;
   private boolean enableAssertions;
+  private boolean optimizePrecompile = false;
   private JsOutputOption output = JsOutputOption.OBFUSCATED;
   private boolean runAsyncEnabled = true;
   private boolean soycEnabled = false;
@@ -79,6 +80,10 @@
     return enableAssertions;
   }
 
+  public boolean isOptimizePrecompile() {
+    return optimizePrecompile;
+  }
+
   public boolean isRunAsyncEnabled() {
     return runAsyncEnabled;
   }
@@ -111,6 +116,10 @@
     this.enableAssertions = enableAssertions;
   }
 
+  public void setOptimizePrecompile(boolean optimize) {
+    optimizePrecompile = optimize;
+  }
+
   public void setOutput(JsOutputOption output) {
     this.output = output;
   }
diff --git a/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java b/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
index 743472b..282e4a1 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
@@ -517,17 +517,31 @@
       JavaScriptObjectNormalizer.exec(jprogram);
 
       /*
-       * (4) Minimally optimize the normalized Java AST for the common AST. By
-       * doing a few optimizations early in the multiple permutation scenario,
-       * we can save some work. However, we don't do full optimizations because
-       * our optimizer is currently superlinear, which can lead to net losses
-       * for big apps. We can't fully optimize because we don't yet know the
-       * deferred binding decisions.
+       * 4) Possibly optimize some.
        * 
-       * Don't bother optimizing early if there's only one permutation.
+       * Don't optimizing early if this is a draft compile, or if there's only
+       * one permutation.
        */
-      if (!singlePermutation) {
-        optimizeLoop(jprogram, false);
+      if (!options.isDraftCompile() && !singlePermutation) {
+        if (options.isOptimizePrecompile()) {
+          /*
+           * Go ahead and optimize early, so that each permutation will run
+           * faster. This code path is used by the Compiler entry point. We
+           * assume that we will not be able to perfectly parallelize the
+           * permutation compiles, so let's optimize as much as possible the
+           * common AST. In some cases, this might also have the side benefit of
+           * reducing the total permutation count.
+           */
+          optimize(options, jprogram);
+        } else {
+          /*
+           * Do only minimal early optimizations. This code path is used by the
+           * Precompile entry point. The external system might be able to
+           * perfectly parallelize the permutation compiles, so let's avoid
+           * doing potentially superlinear optimizations on the unified AST.
+           */
+          optimizeLoop(jprogram, false);
+        }
       }
 
       Set<String> rebindRequests = new HashSet<String>();
diff --git a/dev/core/src/com/google/gwt/dev/util/arg/OptionOptimizePrecompile.java b/dev/core/src/com/google/gwt/dev/util/arg/OptionOptimizePrecompile.java
new file mode 100755
index 0000000..e2a6d7b
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/util/arg/OptionOptimizePrecompile.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev.util.arg;
+
+/**
+ * Option to early optimize the unified AST during a precompile. Does not
+ * correspond to any command line option. This is used directly by compiler
+ * clients to specify whether or not to optimize early.
+ */
+public interface OptionOptimizePrecompile {
+  boolean isOptimizePrecompile();
+
+  void setOptimizePrecompile(boolean optimize);
+}