# HG changeset patch
# User jlahoda@slc05kwy.us.oracle.com
# Date 1432113909 25200
#      Wed May 20 02:25:09 2015 -0700
# Node ID df065f6dc7fc6d2d66d200c115960da62d87a244
# Parent  6bc40a5172e8dcf807a061c94ab6843d11f9d203
JDK-8058150

diff --git a/src/jdk.compiler/share/classes/META-INF/services/com.sun.tools.javac.platform.PlatformProviderFactory b/src/jdk.compiler/share/classes/META-INF/services/com.sun.tools.javac.platform.PlatformProviderFactory
new file mode 100644
--- /dev/null
+++ b/src/jdk.compiler/share/classes/META-INF/services/com.sun.tools.javac.platform.PlatformProviderFactory
@@ -0,0 +1,1 @@
+com.sun.tools.javac.platform.JDKPlatformProvider
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/api/BasicJavacTask.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/api/BasicJavacTask.java
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/api/BasicJavacTask.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/api/BasicJavacTask.java
@@ -29,6 +29,7 @@
 import java.util.LinkedHashSet;
 import java.util.Locale;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import javax.annotation.processing.Processor;
 import javax.lang.model.element.Element;
@@ -46,6 +47,8 @@
 import com.sun.tools.javac.main.JavaCompiler;
 import com.sun.tools.javac.model.JavacElements;
 import com.sun.tools.javac.model.JavacTypes;
+import com.sun.tools.javac.platform.PlatformProvider;
+import com.sun.tools.javac.platform.PlatformProvider.PluginInfo;
 import com.sun.tools.javac.processing.JavacProcessingEnvironment;
 import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.util.Context;
@@ -171,6 +174,22 @@
     }
 
     public void initPlugins(Set<List<String>> pluginOpts) {
+        PlatformProvider platformProvider = context.get(PlatformProvider.class);
+
+        if (platformProvider != null) {
+            for (PluginInfo<Plugin> pluginDesc : platformProvider.getPlugins()) {
+                java.util.List<String> options =
+                        pluginDesc.getOptions().entrySet().stream()
+                                                          .map(e -> e.getKey() + "=" + e.getValue())
+                                                          .collect(Collectors.toList());
+                try {
+                    pluginDesc.getPlugin().init(this, options.toArray(new String[options.size()]));
+                } catch (RuntimeException ex) {
+                    throw new PropagatedException(ex);
+                }
+            }
+        }
+
         if (pluginOpts.isEmpty())
             return;
 
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/ClassFinder.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/ClassFinder.java
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/ClassFinder.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/ClassFinder.java
@@ -50,6 +50,7 @@
 import com.sun.tools.javac.file.JavacFileManager;
 import com.sun.tools.javac.jvm.ClassReader;
 import com.sun.tools.javac.jvm.Profile;
+import com.sun.tools.javac.platform.PlatformProvider;
 import com.sun.tools.javac.util.*;
 
 import static javax.tools.StandardLocation.*;
@@ -58,6 +59,7 @@
 import static com.sun.tools.javac.code.Kinds.Kind.*;
 
 import static com.sun.tools.javac.main.Option.*;
+
 import com.sun.tools.javac.util.Dependencies.CompletionCause;
 
 /**
@@ -98,6 +100,11 @@
      */
     protected boolean userPathsFirst;
 
+    /**
+     * Switch: should read OTHER classfiles (.sig files) from PLATFORM_CLASS_PATH.
+     */
+    private boolean allowSigFiles;
+
     /** The log to use for verbose output
      */
     final Log log;
@@ -192,6 +199,7 @@
         cacheCompletionFailure = options.isUnset("dev");
         preferSource = "source".equals(options.get("-Xprefer"));
         userPathsFirst = options.isSet(XXUSERPATHSFIRST);
+        allowSigFiles = context.get(PlatformProvider.class) != null;
 
         completionFailureName =
             options.isSet("failcomplete")
@@ -337,7 +345,8 @@
                 if (verbose) {
                     log.printVerbose("loading", currentClassFile.toString());
                 }
-                if (classfile.getKind() == JavaFileObject.Kind.CLASS) {
+                if (classfile.getKind() == JavaFileObject.Kind.CLASS ||
+                    classfile.getKind() == JavaFileObject.Kind.OTHER) {
                     reader.readClassFile(c);
                     c.flags_field |= getSupplementaryFlags(c);
                 } else {
@@ -418,7 +427,7 @@
                 q.flags_field |= EXISTS;
         JavaFileObject.Kind kind = file.getKind();
         int seen;
-        if (kind == JavaFileObject.Kind.CLASS)
+        if (kind == JavaFileObject.Kind.CLASS || kind == JavaFileObject.Kind.OTHER)
             seen = CLASS_SEEN;
         else
             seen = SOURCE_SEEN;
@@ -581,10 +590,13 @@
         fillIn(p, PLATFORM_CLASS_PATH,
                fileManager.list(PLATFORM_CLASS_PATH,
                                 p.fullname.toString(),
-                                EnumSet.of(JavaFileObject.Kind.CLASS),
+                                allowSigFiles ? EnumSet.of(JavaFileObject.Kind.CLASS,
+                                                           JavaFileObject.Kind.OTHER)
+                                              : EnumSet.of(JavaFileObject.Kind.CLASS),
                                 false));
     }
     // where
+        @SuppressWarnings("fallthrough")
         private void fillIn(PackageSymbol p,
                             Location location,
                             Iterable<JavaFileObject> files)
@@ -592,6 +604,15 @@
             currentLoc = location;
             for (JavaFileObject fo : files) {
                 switch (fo.getKind()) {
+                case OTHER:
+                    boolean sigFile = location == PLATFORM_CLASS_PATH &&
+                                      allowSigFiles &&
+                                      fo.getName().endsWith(".sig");
+                    if (!sigFile) {
+                        extraFileActions(p, fo);
+                        break;
+                    }
+                    //intentional fall-through:
                 case CLASS:
                 case SOURCE: {
                     // TODO pass binaryName to includeClassFile
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/file/JavacFileManager.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/file/JavacFileManager.java
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/file/JavacFileManager.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/file/JavacFileManager.java
@@ -331,6 +331,8 @@
 
         for (Path f: files) {
             String fname = f.getFileName().toString();
+            if (fname.endsWith("/"))
+                fname = fname.substring(0, fname.length() - 1);
             if (Files.isDirectory(f)) {
                 if (recurse && SourceVersion.isIdentifier(fname)) {
                     listDirectory(directory,
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/ClassReader.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/ClassReader.java
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/ClassReader.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/ClassReader.java
@@ -1317,13 +1317,28 @@
             for (int i = 0; i<numAttributes; i++) {
                 CompoundAnnotationProxy proxy = readCompoundAnnotation();
 
-                if (proxy.type.tsym == syms.annotationTargetType.tsym) {
-                    target = proxy;
-                } else if (proxy.type.tsym == syms.repeatableType.tsym) {
-                    repeatable = proxy;
+                if (proxy.type.tsym == syms.proprietaryType.tsym)
+                    sym.flags_field |= PROPRIETARY;
+                else if (proxy.type.tsym == syms.profileType.tsym) {
+                    if (profile != Profile.DEFAULT) {
+                        for (Pair<Name,Attribute> v: proxy.values) {
+                            if (v.fst == names.value && v.snd instanceof Attribute.Constant) {
+                                Attribute.Constant c = (Attribute.Constant) v.snd;
+                                if (c.type == syms.intType && ((Integer) c.value) > profile.value) {
+                                    sym.flags_field |= NOT_IN_PROFILE;
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    if (proxy.type.tsym == syms.annotationTargetType.tsym) {
+                        target = proxy;
+                    } else if (proxy.type.tsym == syms.repeatableType.tsym) {
+                        repeatable = proxy;
+                    }
+
+                    proxies.append(proxy);
                 }
-
-                proxies.append(proxy);
             }
             annotate.normal(new AnnotationCompleter(sym, proxies.toList()));
         }
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/main/Arguments.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/main/Arguments.java
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/main/Arguments.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/main/Arguments.java
@@ -25,29 +25,38 @@
 package com.sun.tools.javac.main;
 
 import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.Map;
+import java.util.ServiceLoader;
 import java.util.Set;
 
 import javax.tools.JavaFileManager;
 import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.StandardLocation;
 
 import com.sun.tools.doclint.DocLint;
 import com.sun.tools.javac.code.Lint.LintCategory;
 import com.sun.tools.javac.code.Source;
+import com.sun.tools.javac.file.BaseFileManager;
 import com.sun.tools.javac.file.JavacFileManager;
 import com.sun.tools.javac.jvm.Profile;
 import com.sun.tools.javac.jvm.Target;
 import com.sun.tools.javac.main.OptionHelper.GrumpyHelper;
-import com.sun.tools.javac.file.BaseFileManager;
+import com.sun.tools.javac.platform.PlatformProvider;
+import com.sun.tools.javac.platform.PlatformProviderFactory;
 import com.sun.tools.javac.util.Context;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.util.ListBuffer;
 import com.sun.tools.javac.util.Log;
 import com.sun.tools.javac.util.Log.PrefixKind;
+import com.sun.tools.javac.util.Log.WriterKind;
 import com.sun.tools.javac.util.Options;
 import com.sun.tools.javac.util.PropagatedException;
 
@@ -272,6 +281,63 @@
     private boolean processArgs(Iterable<String> args,
             Set<Option> allowableOpts, OptionHelper helper,
             boolean allowOperands, boolean checkFileManager) {
+        if (!doProcessArgs(args, allowableOpts, helper, allowOperands, checkFileManager))
+            return false;
+
+        String platformString = options.get(Option.PLATFORM);
+
+        checkOptionAllowed(platformString == null,
+                option -> error("err.platform.bootclasspath.conflict", option.getText()),
+                Option.BOOTCLASSPATH, Option.XBOOTCLASSPATH, Option.XBOOTCLASSPATH_APPEND,
+                Option.XBOOTCLASSPATH_PREPEND, Option.ENDORSEDDIRS, Option.EXTDIRS, Option.SOURCE,
+                Option.TARGET);
+
+        if (platformString != null) {
+            PlatformProvider platformProvider = lookupPlatformProvider(platformString);
+
+            if (platformProvider == null) {
+                error("err.unsupported.platform.version", platformString);
+                return false;
+            }
+
+            options.put(Option.SOURCE, platformProvider.getSourceVersion());
+            options.put(Option.TARGET, platformProvider.getTargetVersion());
+
+            context.put(PlatformProvider.class, platformProvider);
+
+            if (!doProcessArgs(platformProvider.getAdditionalOptions(), allowableOpts, helper, allowOperands, checkFileManager))
+                return false;
+
+            Collection<Path> platformCP = platformProvider.getPlatformPath();
+
+            if (platformCP != null) {
+                JavaFileManager fm = getFileManager();
+
+                if (!(fm instanceof StandardJavaFileManager)) {
+                    error("err.platform.not.standard.file.manager");
+                    return false;
+                }
+
+                try {
+                    StandardJavaFileManager sfm = (StandardJavaFileManager) fm;
+
+                    sfm.setLocationFromPaths(StandardLocation.PLATFORM_CLASS_PATH, platformCP);
+                } catch (IOException ex) {
+                    log.printLines(PrefixKind.JAVAC, "msg.io");
+                    ex.printStackTrace(log.getWriter(WriterKind.NOTICE));
+                    return false;
+                }
+            }
+        }
+
+        options.notifyListeners();
+
+        return true;
+    }
+
+    private boolean doProcessArgs(Iterable<String> args,
+            Set<Option> allowableOpts, OptionHelper helper,
+            boolean allowOperands, boolean checkFileManager) {
         JavaFileManager fm = checkFileManager ? getFileManager() : null;
         Iterator<String> argIter = args.iterator();
         while (argIter.hasNext()) {
@@ -315,11 +381,8 @@
                     return false;
                 }
             }
-
         }
 
-        options.notifyListeners();
-
         return true;
     }
 
@@ -405,14 +468,14 @@
 
         boolean lintOptions = options.isUnset(Option.XLINT_CUSTOM, "-" + LintCategory.OPTIONS.option);
 
-        if (lintOptions && source.compareTo(Source.DEFAULT) < 0) {
+        if (lintOptions && source.compareTo(Source.DEFAULT) < 0 && !options.isSet(Option.PLATFORM)) {
             JavaFileManager fm = getFileManager();
             if (fm instanceof BaseFileManager) {
                 if (((BaseFileManager) fm).isDefaultBootClassPath())
                     log.warning(LintCategory.OPTIONS, "source.no.bootclasspath", source.name);
             }
         }
-
+        
         boolean obsoleteOptionFound = false;
 
         if (source.compareTo(Source.MIN) < 0) {
@@ -435,6 +498,20 @@
         return !errors;
     }
 
+    private PlatformProvider lookupPlatformProvider(String platform) {
+        Iterable<PlatformProviderFactory> factories =
+                ServiceLoader.load(PlatformProviderFactory.class, Arguments.class.getClassLoader());
+        for (PlatformProviderFactory factory : factories) {
+            for (PlatformProvider provider : factory.createPlatformProviders()) {
+                if (provider.getName().equals(platform)) {
+                    return provider;
+                }
+            }
+        }
+
+        return null;
+    }
+
     /**
      * Returns true if there are no files or classes specified for use.
      * @return true if there are no files or classes specified for use
@@ -528,6 +605,19 @@
         return true;
     }
 
+    private interface ErrorReporter {
+        void report(Option o);
+    }
+
+    void checkOptionAllowed(boolean allowed, ErrorReporter r, Option... opts) {
+        if (!allowed) {
+            for (Option o: opts) {
+                if (options.isSet(o))
+                    r.report(o);
+            }
+        }
+    }
+
     void error(String key, Object... args) {
         errors = true;
         switch (errorMode) {
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/main/JavaCompiler.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/main/JavaCompiler.java
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/main/JavaCompiler.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/main/JavaCompiler.java
@@ -56,6 +56,7 @@
 import com.sun.tools.javac.file.JavacFileManager;
 import com.sun.tools.javac.jvm.*;
 import com.sun.tools.javac.parser.*;
+import com.sun.tools.javac.platform.PlatformProvider;
 import com.sun.tools.javac.processing.*;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.tree.JCTree.JCClassDecl;
@@ -429,6 +430,11 @@
 
         if (options.isUnset("oldDiags"))
             log.setDiagnosticFormatter(RichDiagnosticFormatter.instance(context));
+
+        PlatformProvider platformProvider = context.get(PlatformProvider.class);
+
+        if (platformProvider != null)
+            closeables = closeables.prepend(platformProvider);
     }
 
     /* Switches:
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/main/Main.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/main/Main.java
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/main/Main.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/main/Main.java
@@ -41,6 +41,7 @@
 import com.sun.tools.javac.file.CacheFSInfo;
 import com.sun.tools.javac.file.BaseFileManager;
 import com.sun.tools.javac.file.JavacFileManager;
+import com.sun.tools.javac.platform.PlatformProvider;
 import com.sun.tools.javac.processing.AnnotationProcessingError;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.Log.PrefixKind;
@@ -229,7 +230,7 @@
 
         // init plugins
         Set<List<String>> pluginOpts = args.getPluginOpts();
-        if (!pluginOpts.isEmpty()) {
+        if (!pluginOpts.isEmpty() || context.get(PlatformProvider.class) != null) {
             BasicJavacTask t = (BasicJavacTask) BasicJavacTask.instance(context);
             t.initPlugins(pluginOpts);
         }
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/main/Option.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/main/Option.java
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/main/Option.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/main/Option.java
@@ -32,7 +32,9 @@
 import java.util.EnumSet;
 import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.ServiceLoader;
 import java.util.Set;
+import java.util.TreeSet;
 
 import javax.lang.model.SourceVersion;
 
@@ -43,12 +45,15 @@
 import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.jvm.Profile;
 import com.sun.tools.javac.jvm.Target;
+import com.sun.tools.javac.platform.PlatformProvider;
+import com.sun.tools.javac.platform.PlatformProviderFactory;
 import com.sun.tools.javac.processing.JavacProcessingEnvironment;
 import com.sun.tools.javac.util.Log;
 import com.sun.tools.javac.util.Log.PrefixKind;
 import com.sun.tools.javac.util.Log.WriterKind;
 import com.sun.tools.javac.util.Options;
 import com.sun.tools.javac.util.StringUtils;
+
 import static com.sun.tools.javac.main.Option.ChoiceKind.*;
 import static com.sun.tools.javac.main.Option.OptionGroup.*;
 import static com.sun.tools.javac.main.Option.OptionKind.*;
@@ -264,6 +269,37 @@
         }
     },
 
+    PLATFORM("-platform", "opt.arg.platform", "opt.platform", STANDARD, BASIC) {
+        @Override
+        void help(Log log, OptionKind kind) {
+            if (this.kind != kind)
+                return;
+
+            Iterable<PlatformProviderFactory> factories =
+                    ServiceLoader.load(PlatformProviderFactory.class, Arguments.class.getClassLoader());
+            Set<String> platforms = new TreeSet<>();
+
+            for (PlatformProviderFactory factory : factories) {
+                for (PlatformProvider platform : factory.createPlatformProviders()) {
+                    platforms.add(platform.getName());
+                }
+            }
+
+            StringBuilder targets = new StringBuilder();
+            String delim = "";
+            for (String platform : platforms) {
+                targets.append(delim);
+                targets.append(platform);
+                delim = ", ";
+            }
+
+            log.printRawLines(WriterKind.NOTICE,
+                    String.format(HELP_LINE_FORMAT,
+                        super.helpSynopsis(log),
+                        log.localize(PrefixKind.JAVAC, descrKey, targets.toString())));
+        }
+    },
+
     PROFILE("-profile", "opt.arg.profile", "opt.profile", STANDARD, BASIC) {
         @Override
         public boolean process(OptionHelper helper, String option, String operand) {
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/platform/JDKPlatformProvider.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/platform/JDKPlatformProvider.java
new file mode 100644
--- /dev/null
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/platform/JDKPlatformProvider.java
@@ -0,0 +1,191 @@
+/*
+ * 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+package com.sun.tools.javac.platform;
+
+import java.io.IOException;
+import java.nio.file.DirectoryStream;
+import java.nio.file.FileSystem;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+
+import javax.annotation.processing.Processor;
+
+import com.sun.source.util.Plugin;
+import com.sun.tools.javac.jvm.Target;
+
+/** PlatformProvider for JDK N.
+ * 
+ *  <p><b>This is NOT part of any supported API.
+ *  If you write code that depends on this, you do so at your own risk.
+ *  This code and its internal interfaces are subject to change or
+ *  deletion without notice.</b>
+ */
+public class JDKPlatformProvider implements PlatformProviderFactory {
+
+    @Override
+    public Iterable<PlatformProvider> createPlatformProviders() {
+        return SUPPORTED_JAVA_PLATFORM_VERSIONS.stream()
+                                               .map(version -> new PlatformProviderImpl(version))
+                                               .collect(Collectors.toList());
+    }
+    
+    private static final String[] symbolFileLocation = { "lib", "ct.sym" };
+
+    private static final Set<String> SUPPORTED_JAVA_PLATFORM_VERSIONS;
+
+    static {
+        SUPPORTED_JAVA_PLATFORM_VERSIONS = new TreeSet<>();
+        Path ctSymFile = findCtSym();
+        if (Files.exists(ctSymFile)) {
+            try (FileSystem fs = FileSystems.newFileSystem(ctSymFile, null);
+                 DirectoryStream<Path> dir =
+                         Files.newDirectoryStream(fs.getRootDirectories().iterator().next())) {
+                for (Path section : dir) {
+                    for (char ver : section.getFileName().toString().toCharArray()) {
+                        String verString = Character.toString(ver);
+                        Target t = Target.lookup(verString);
+
+                        if (t != null) {
+                            SUPPORTED_JAVA_PLATFORM_VERSIONS.add(targetNumericVersion(t));
+                        }
+                    }
+                }
+            } catch (IOException ex) {
+                //XXX: can handle somehow? Print a warning?
+            }
+        }
+        SUPPORTED_JAVA_PLATFORM_VERSIONS.add(targetNumericVersion(Target.DEFAULT));
+    }
+
+    private static String targetNumericVersion(Target target) {
+        return Integer.toString(target.ordinal() - Target.JDK1_1.ordinal() + 1);
+    }
+
+    static class PlatformProviderImpl implements PlatformProvider {
+
+        private final Map<Path, FileSystem> ctSym2FileSystem = new HashMap<>();
+        private final String version;
+
+        PlatformProviderImpl(String version) {
+            this.version = version;
+        }
+
+        @Override
+        public String getName() {
+            return version;
+        }
+
+        @Override
+        public Collection<Path> getPlatformPath() {
+            if (Target.lookup(version) == Target.DEFAULT) {
+                return null;
+            }
+
+            List<Path> paths = new ArrayList<>();
+            Path file = findCtSym();
+            // file == ${jdk.home}/lib/ct.sym
+            if (Files.exists(file)) {
+                FileSystem fs = ctSym2FileSystem.get(file);
+                if (fs == null) {
+                    try {
+                        ctSym2FileSystem.put(file, fs = FileSystems.newFileSystem(file, null));
+                    } catch (IOException ex) {
+                        throw new IllegalStateException(ex);
+                    }
+                }
+                Path root = fs.getRootDirectories().iterator().next();
+                try (DirectoryStream<Path> dir = Files.newDirectoryStream(root)) {
+                    for (Path section : dir) {
+                        if (section.getFileName().toString().contains(version)) {
+                            paths.add(section);
+                        }
+                    }
+                } catch (IOException ex) {
+                    throw new IllegalStateException(ex);
+                }
+            } else {
+                throw new IllegalStateException("Cannot find ct.sym!");
+            }
+            return paths;
+        }
+
+        @Override
+        public String getSourceVersion() {
+            return version;
+        }
+
+        @Override
+        public String getTargetVersion() {
+            return version;
+        }
+
+        @Override
+        public List<PluginInfo<Processor>> getAnnotationProcessors() {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public List<PluginInfo<Plugin>> getPlugins() {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public List<String> getAdditionalOptions() {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public void close() throws IOException {
+            for (FileSystem fs : ctSym2FileSystem.values()) {
+                fs.close();
+            }
+            ctSym2FileSystem.clear();
+        }
+
+    }
+    
+    static Path findCtSym() {
+        String javaHome = System.getProperty("java.home");
+        Path file = Paths.get(javaHome);
+        if (file.getFileName().equals(Paths.get("jre")))
+            file = file.getParent();
+        // file == ${jdk.home}
+        for (String name : symbolFileLocation)
+            file = file.resolve(name);
+        return file;
+    }
+
+}
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/platform/PlatformProvider.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/platform/PlatformProvider.java
new file mode 100644
--- /dev/null
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/platform/PlatformProvider.java
@@ -0,0 +1,124 @@
+/*
+ * 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+package com.sun.tools.javac.platform;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.processing.Processor;
+
+import com.sun.source.util.Plugin;
+
+/**A platform what can be selected using -platform &lt;name&gt; command line option.
+ *
+ *  <p><b>This is NOT part of any supported API.
+ *  If you write code that depends on this, you do so at your own risk.
+ *  This code and its internal interfaces are subject to change or
+ *  deletion without notice.</b>
+ */
+public interface PlatformProvider extends Closeable {
+
+    /**Name of the platform, will be used as the key for -platform.
+     *
+     * @return the platform key
+     */
+    String getName();
+
+    /**Return paths that should be used as the current platforms's bootclasspath, or null if
+     * the default should be used.
+     *
+     * @return the current platforms's bootclasspath, or null for default
+     */
+    Collection<Path> getPlatformPath();
+
+    /**The source version that should be selected. Equivalent to -source N on the command line.
+     *
+     * @return the required source version
+     */
+    String getSourceVersion();
+
+    /**The target version that should be selected. Equivalent to -target N on the command line.
+     *
+     * @return the required target version
+     */
+    String getTargetVersion();
+
+    /**Description of annotation Processor or javac Plugin that should be enabled in the current
+     * javac run.
+     *
+     * @param <T> either Processor or Plugin
+     */
+    interface PluginInfo<T> {
+
+        /**The name of the Processor or Plugin.
+         *
+         * @return name of the Processor or Plugin.
+         */
+        String getName();
+
+        /**Options for the Processor or Plugin. For plugin, the map will be converted to a collection
+         * by concatenating the map's keys, the '=' sign and the map's values.
+         *
+         *
+         * @return the options
+         */
+        Map<String, String> getOptions();
+
+        /**The Processor or Plugin instance.
+         *
+         * @return the Processor or Plugin instance.
+         */
+        T getPlugin();
+    }
+
+    /**Annotation Processors that should be enabled in the current javac run.
+     *
+     * @return annotation Processors
+     */
+    List<PluginInfo<Processor>> getAnnotationProcessors();
+
+    /**javac Plugins that should be enabled in the current javac run.
+     *
+     * @return javac Plugins
+     */
+    List<PluginInfo<Plugin>> getPlugins();
+
+    /**Additional command line options that should be passed to javac.
+     *
+     * @return additional command line options
+     */
+    List<String> getAdditionalOptions();
+
+    /**Perform cleanup for this PlatformProvider - this instance won't be used after this method
+     * is called.
+     *
+     * @throws IOException if unexpected problems occur during closing this provider
+     */
+    void close() throws IOException;
+}
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/platform/PlatformProviderFactory.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/platform/PlatformProviderFactory.java
new file mode 100644
--- /dev/null
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/platform/PlatformProviderFactory.java
@@ -0,0 +1,44 @@
+/*
+ * 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+package com.sun.tools.javac.platform;
+
+/** A factory to create PlatformProviders.
+ *  Register in {@code META-INF/services/com.sun.tools.javac.platform.PlatformProviderFactory}.
+ *
+ *  <p><b>This is NOT part of any supported API.
+ *  If you write code that depends on this, you do so at your own risk.
+ *  This code and its internal interfaces are subject to change or
+ *  deletion without notice.</b>
+ */
+public interface PlatformProviderFactory {
+
+    /**Create PlatformProviders supported by this factory.
+     *
+     * @return a list of platform providers.
+     */
+    public abstract Iterable<PlatformProvider> createPlatformProviders();
+
+}
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java
@@ -33,6 +33,7 @@
 import java.net.URL;
 import java.util.*;
 import java.util.regex.*;
+import java.util.stream.Collectors;
 
 import javax.annotation.processing.*;
 import javax.lang.model.SourceVersion;
@@ -57,6 +58,8 @@
 import com.sun.tools.javac.main.JavaCompiler;
 import com.sun.tools.javac.model.JavacElements;
 import com.sun.tools.javac.model.JavacTypes;
+import com.sun.tools.javac.platform.PlatformProvider;
+import com.sun.tools.javac.platform.PlatformProvider.PluginInfo;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.tree.JCTree.*;
 import com.sun.tools.javac.util.Abort;
@@ -282,7 +285,41 @@
                         processorClassLoaderException);
             }
         }
-        discoveredProcs = new DiscoveredProcessors(processorIterator);
+        PlatformProvider platformProvider = context.get(PlatformProvider.class);
+        java.util.List<Processor> platformProcessors = Collections.emptyList();
+        if (platformProvider != null) {
+            platformProcessors = platformProvider.getAnnotationProcessors()
+                                                 .stream()
+                                                 .map(ap -> ap.getPlugin())
+                                                 .collect(Collectors.toList());
+        }
+        discoveredProcs = new DiscoveredProcessors(new JoiningIterator(List.of(processorIterator, platformProcessors.iterator())));
+    }
+
+    private static final class JoiningIterator implements Iterator<Processor> {
+        private List<Iterator<? extends Processor>> delegateTo;
+
+        public JoiningIterator(List<Iterator<? extends Processor>> delegateTo) {
+            this.delegateTo = delegateTo;
+        }
+
+        @Override
+        public boolean hasNext() {
+            while (delegateTo.nonEmpty() && !delegateTo.head.hasNext())
+                delegateTo = delegateTo.tail;
+
+            return delegateTo.nonEmpty();
+        }
+
+        @Override
+        public Processor next() {
+            if (delegateTo.isEmpty()) {
+                throw new NoSuchElementException();
+            }
+
+            return delegateTo.head.next();
+        }
+
     }
 
     /**
@@ -481,6 +518,14 @@
             }
         }
 
+        PlatformProvider platformProvider = context.get(PlatformProvider.class);
+
+        if (platformProvider != null) {
+            for (PluginInfo<Processor> ap : platformProvider.getAnnotationProcessors()) {
+                tempOptions.putAll(ap.getOptions());
+            }
+        }
+
         return Collections.unmodifiableMap(tempOptions);
     }
 
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/javac.properties b/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/javac.properties
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/javac.properties
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/javac.properties
@@ -73,6 +73,8 @@
     Check that API used is available in the specified profile
 javac.opt.target=\
     Generate class files for specific VM version
+javac.opt.platform=\
+    Compile for a specific VM version. Supported targets: {0}
 javac.opt.source=\
     Provide source compatibility with specified release
 javac.opt.Werror=\
@@ -103,6 +105,8 @@
     <profile>
 javac.opt.arg.release=\
     <release>
+javac.opt.arg.platform=\
+    <platform>
 javac.opt.arg.number=\
     <number>
 javac.opt.plugin=\
@@ -338,3 +342,12 @@
 
 javac.version={0} {1}
 javac.fullVersion={0} full version "{1}"
+
+javac.err.platform.bootclasspath.conflict=\
+    option {0} cannot be used together with -platform
+
+javac.err.unsupported.platform.version=\
+    platform version {0} not supported
+
+javac.err.platform.not.standard.file.manager=\
+    -platform option specified, but the provided JavaFileManager is not a StandardJavaFileManager.
diff --git a/test/tools/javac/options/platform/PlatformOption-platform7.out b/test/tools/javac/options/platform/PlatformOption-platform7.out
new file mode 100644
--- /dev/null
+++ b/test/tools/javac/options/platform/PlatformOption-platform7.out
@@ -0,0 +1,2 @@
+PlatformOption.java:9:50: compiler.err.doesnt.exist: java.util.stream
+1 error
diff --git a/test/tools/javac/options/platform/PlatformOption.java b/test/tools/javac/options/platform/PlatformOption.java
new file mode 100644
--- /dev/null
+++ b/test/tools/javac/options/platform/PlatformOption.java
@@ -0,0 +1,10 @@
+/**
+ * @test /nodynamiccopyright/
+ * @bug 8072480
+ * @summary Verify that javac rejects Java 8 program with -platform 7
+ * @compile PlatformOption.java
+ * @compile/fail/ref=PlatformOption-platform7.out -XDrawDiagnostics -platform 7 PlatformOption.java
+ */
+
+interface PlatformOption extends java.util.stream.Stream {
+}
diff --git a/test/tools/javac/options/platform/PlatformOptionClashes.java b/test/tools/javac/options/platform/PlatformOptionClashes.java
new file mode 100644
--- /dev/null
+++ b/test/tools/javac/options/platform/PlatformOptionClashes.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2015, 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.
+ */
+
+/**
+ * @test
+ * @bug 8072480
+ * @summary Verify option clash between -platform and -source is reported correctly.
+ */
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import javax.tools.Tool;
+import javax.tools.ToolProvider;
+
+public class PlatformOptionClashes {
+    public static void main(String... args) throws Exception {
+        new PlatformOptionClashes().run();
+    }
+
+    void run() throws Exception {
+        doRunTest("-bootclasspath", "any");
+        doRunTest("-Xbootclasspath:any");
+        doRunTest("-Xbootclasspath/a:any");
+        doRunTest("-Xbootclasspath/p:any");
+        doRunTest("-endorseddirs", "any");
+        doRunTest("-extdirs", "any");
+        doRunTest("-source", "8");
+        doRunTest("-target", "8");
+    }
+
+    void doRunTest(String... args) throws Exception {
+        System.out.println("Testing clashes for arguments: " + Arrays.asList(args));
+        Class<?> log = Class.forName("com.sun.tools.javac.util.Log", true, cl);
+        Field useRawMessages = log.getDeclaredField("useRawMessages");
+        useRawMessages.setAccessible(true);
+        useRawMessages.setBoolean(null, true);
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        List<String> options = new ArrayList<>();
+        options.addAll(Arrays.asList("-platform", "7"));
+        options.addAll(Arrays.asList(args));
+        options.add(System.getProperty("test.src") + File.separator + "PlatformOptionClashes.java");
+        compiler.run(null, null, out, options.toArray(new String[0]));
+        useRawMessages.setBoolean(null, false);
+        if (!out.toString().equals(String.format("%s%n%s%n",
+                                                 "javac: javac.err.platform.bootclasspath.conflict",
+                                                 "javac.msg.usage")) &&
+            //-Xbootclasspath:any produces two warnings: one for -bootclasspath and one for -Xbootclasspath:
+            !out.toString().equals(String.format("%s%n%s%n%s%n%s%n",
+                                                 "javac: javac.err.platform.bootclasspath.conflict",
+                                                 "javac.msg.usage",
+                                                 "javac: javac.err.platform.bootclasspath.conflict",
+                                                 "javac.msg.usage"))) {
+            throw new AssertionError(out);
+        }
+        System.out.println("Test PASSED.  Running javac again to see localized output:");
+        compiler.run(null, null, System.out, options.toArray(new String[0]));
+    }
+
+    ClassLoader cl = ToolProvider.getSystemToolClassLoader();
+    Tool compiler = ToolProvider.getSystemJavaCompiler();
+}
\ No newline at end of file
diff --git a/test/tools/javac/options/platform/PlatformOptionThroughAPI.java b/test/tools/javac/options/platform/PlatformOptionThroughAPI.java
new file mode 100644
--- /dev/null
+++ b/test/tools/javac/options/platform/PlatformOptionThroughAPI.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2015, 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.
+ */
+
+/**
+ * @test
+ * @bug 8072480
+ * @summary Verify that javac can handle -platform when invoked using the Compiler API
+ */
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.Arrays;
+import java.util.List;
+import javax.tools.JavaCompiler;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.ToolProvider;
+
+public class PlatformOptionThroughAPI {
+    public static void main(String... args) throws IOException {
+        new PlatformOptionThroughAPI().run();
+    }
+
+    void run() throws IOException {
+        String lineSep = System.getProperty("line.separator");
+        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+        try (StandardJavaFileManager fm = compiler.getStandardFileManager(null, null, null);
+             StringWriter out = new StringWriter();
+             PrintWriter outWriter = new PrintWriter(out)) {
+            Iterable<? extends JavaFileObject> input =
+                    fm.getJavaFileObjects(System.getProperty("test.src") + "/PlatformOption.java");
+            List<String> options = Arrays.asList("-platform", "7", "-XDrawDiagnostics");
+
+            compiler.getTask(outWriter, fm, null, options, null, input).call();
+            String expected =
+                    "PlatformOption.java:9:50: compiler.err.doesnt.exist: java.util.stream" + lineSep +
+                    "1 error" + lineSep;
+            if (!expected.equals(out.toString())) {
+                throw new AssertionError("Unexpected output: " + out.toString());
+            }
+        }
+    }
+}
diff --git a/test/tools/javac/platform/PlatformProviderTest.java b/test/tools/javac/platform/PlatformProviderTest.java
new file mode 100644
--- /dev/null
+++ b/test/tools/javac/platform/PlatformProviderTest.java
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2015, 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.
+ */
+
+/**
+ * @test
+ * @bug 8072480
+ * @summary Ensure all methods of PlatformProvider are called correctly, and their result is used
+ *          correctly.
+ * @library /tools/lib
+ * @build ToolBox PlatformProviderTest
+ * @run main PlatformProviderTest
+ */
+
+import java.io.IOException;
+import java.io.Writer;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.Processor;
+import javax.annotation.processing.RoundEnvironment;
+import javax.annotation.processing.SupportedAnnotationTypes;
+import javax.annotation.processing.SupportedOptions;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.TypeElement;
+import javax.tools.JavaCompiler;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.StandardLocation;
+import javax.tools.ToolProvider;
+
+import com.sun.source.util.JavacTask;
+import com.sun.source.util.Plugin;
+import com.sun.tools.javac.platform.PlatformProvider;
+import com.sun.tools.javac.platform.PlatformProviderFactory;
+
+public class PlatformProviderTest implements PlatformProviderFactory {
+
+    public static void main(String... args) throws IOException {
+        Path registration = Paths.get(System.getProperty("test.classes"),
+                                      "META-INF",
+                                      "services",
+                                      "com.sun.tools.javac.platform.PlatformProviderFactory");
+        Files.createDirectories(registration.getParent());
+        try (Writer metaInf = Files.newBufferedWriter(registration)) {
+            metaInf.write(PlatformProviderTest.class.getName());
+        }
+        ToolBox tb = new ToolBox();
+        ToolBox.Result result =
+                tb.new JavacTask(ToolBox.Mode.EXEC)
+                  .options("-J-classpath",
+                           "-J" + System.getProperty("test.classes"),
+                           "-platform",
+                           "name",
+                           System.getProperty("test.src") + "/PlatformProviderTestSource.java")
+                  .run();
+
+        List<String> expectedOutput =
+                Arrays.asList("getName",
+                              "getSourceVersion",
+                              "getTargetVersion",
+                              "getPlatformPath",
+                              "testPlugin: [testPluginKey=testPluginValue]",
+                              "process: {testAPKey=testAPValue}",
+                              "process: {testAPKey=testAPValue}",
+                              "PlatformProviderTestSource.java:4:49: compiler.warn.raw.class.use: java.util.ArrayList, java.util.ArrayList<E>",
+                              "1 warning",
+                              "close");
+        List<String> actualOutput = result.getOutputLines(ToolBox.OutputKind.STDERR);
+        result.writeAll();
+        if (!expectedOutput.equals(actualOutput)) {
+            throw new AssertionError(  "Expected output: " + expectedOutput +
+                                     "; actual output: " + actualOutput);
+        }
+        result.writeAll();
+    }
+
+    @Override
+    public Iterable<PlatformProvider> createPlatformProviders() {
+        return Arrays.asList(new ProviderImpl());
+    }
+
+    class ProviderImpl implements PlatformProvider {
+
+        private final JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+        private final StandardJavaFileManager fm = compiler.getStandardFileManager(null, null, null);
+        
+        @Override
+        public String getName() {
+            System.err.println("getName");
+            return "name";
+        }
+
+        @Override
+        public Collection<Path> getPlatformPath() {
+            System.err.println("getPlatformPath");
+            List<Path> result = new ArrayList<>();
+            fm.getLocationAsPaths(StandardLocation.PLATFORM_CLASS_PATH).forEach(p -> { result.add(p); });
+            return result;
+        }
+
+        @Override
+        public String getSourceVersion() {
+            System.err.println("getSourceVersion");
+            return "8";
+        }
+
+        @Override
+        public String getTargetVersion() {
+            System.err.println("getTargetVersion");
+            return "8";
+        }
+
+        @Override
+        public List<PluginInfo<Processor>> getAnnotationProcessors() {
+            return Arrays.asList(new PluginInfo<Processor>() {
+                @Override
+                public String getName() {
+                    return "test";
+                }
+                @Override
+                public Map<String, String> getOptions() {
+                    return Collections.singletonMap("testAPKey", "testAPValue");
+                }
+                @Override
+                public Processor getPlugin() {
+                    return new ProcessorImpl();
+                }
+            });
+        }
+
+        @Override
+        public List<PluginInfo<Plugin>> getPlugins() {
+            return Arrays.asList(new PluginInfo<Plugin>() {
+                @Override
+                public String getName() {
+                    return "testPlugin";
+                }
+                @Override
+                public Map<String, String> getOptions() {
+                    return Collections.singletonMap("testPluginKey", "testPluginValue");
+                }
+                @Override
+                public Plugin getPlugin() {
+                    return new PluginImpl();
+                }
+            });
+        }
+
+        @Override
+        public List<String> getAdditionalOptions() {
+            return Arrays.asList("-Xlint:rawtypes", "-XDrawDiagnostics");
+        }
+
+        @Override
+        public void close() throws IOException {
+            System.err.println("close");
+            fm.close();
+        }
+
+    }
+
+    @SupportedAnnotationTypes("*")
+    @SupportedOptions("testAPKey")
+    class ProcessorImpl extends AbstractProcessor {
+
+        @Override
+        public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+            System.err.println("process: " + processingEnv.getOptions());
+            return true;
+        }
+
+        @Override
+        public SourceVersion getSupportedSourceVersion() {
+            return SourceVersion.latest();
+        }
+
+    }
+
+    class PluginImpl implements Plugin {
+
+        @Override
+        public String getName() {
+            return "testPluginName";
+        }
+
+        @Override
+        public void init(JavacTask task, String... args) {
+            System.err.println("testPlugin: " + Arrays.toString(args));
+        }
+
+    }
+}
diff --git a/test/tools/javac/platform/PlatformProviderTestSource.java b/test/tools/javac/platform/PlatformProviderTestSource.java
new file mode 100644
--- /dev/null
+++ b/test/tools/javac/platform/PlatformProviderTestSource.java
@@ -0,0 +1,5 @@
+/* /nodynamiccopyright/ */
+import java.util.ArrayList;
+
+public class PlatformProviderTestSource extends ArrayList {
+}
diff --git a/test/tools/javac/sym/ElementStructureTest.java b/test/tools/javac/sym/ElementStructureTest.java
new file mode 100644
--- /dev/null
+++ b/test/tools/javac/sym/ElementStructureTest.java
@@ -0,0 +1,658 @@
+/*
+ * Copyright (c) 2015, 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.
+ */
+
+/**
+ * @test
+ * @bug 8072480
+ * @summary Check the platform classpath contains the correct elements.
+ * @library /tools/lib
+ * @build ToolBox ElementStructureTest
+ * @run main ElementStructureTest
+ */
+
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Reader;
+import java.io.Writer;
+import java.net.URI;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.security.MessageDigest;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementVisitor;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.NestingKind;
+import javax.lang.model.element.PackageElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.TypeParameterElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeMirror;
+import javax.tools.FileObject;
+import javax.tools.JavaFileManager;
+import javax.tools.JavaFileObject;
+import javax.tools.JavaFileObject.Kind;
+import javax.tools.StandardLocation;
+import javax.tools.ToolProvider;
+
+import com.sun.source.util.JavacTask;
+import com.sun.tools.classfile.ClassFile;
+import com.sun.tools.classfile.ConstantPoolException;
+import com.sun.tools.javac.api.JavacTaskImpl;
+import com.sun.tools.javac.code.Symbol.CompletionFailure;
+import com.sun.tools.javac.platform.PlatformProvider;
+import com.sun.tools.javac.platform.PlatformProviderFactory;
+import com.sun.tools.javac.util.ServiceLoader;
+
+public class ElementStructureTest {
+
+    static final byte[] hash7 = new byte[] {
+        (byte) 0x6B, (byte) 0xA2, (byte) 0xE9, (byte) 0x8E,
+        (byte) 0xE1, (byte) 0x8E, (byte) 0x60, (byte) 0xBE,
+        (byte) 0x54, (byte) 0xC4, (byte) 0x33, (byte) 0x3E,
+        (byte) 0x0C, (byte) 0x2D, (byte) 0x3A, (byte) 0x7C
+    };
+    static final byte[] hash8 = new byte[] {
+        (byte) 0x37, (byte) 0x0C, (byte) 0xBA, (byte) 0xCE,
+        (byte) 0xCF, (byte) 0x81, (byte) 0xAE, (byte) 0xA8,
+        (byte) 0x1E, (byte) 0x10, (byte) 0xAB, (byte) 0x72,
+        (byte) 0xF7, (byte) 0xE5, (byte) 0x34, (byte) 0x72
+    };
+
+    final static Map<String, byte[]> version2Hash = new HashMap<>();
+
+    static {
+        version2Hash.put("7", hash7);
+        version2Hash.put("8", hash8);
+    }
+
+    static final byte[] alternativeHash6 = new byte[] {
+        (byte) 0x99, (byte) 0x34, (byte) 0x82, (byte) 0xCF,
+        (byte) 0xE0, (byte) 0x53, (byte) 0xF3, (byte) 0x13,
+        (byte) 0x4E, (byte) 0xCF, (byte) 0x49, (byte) 0x32,
+        (byte) 0xB7, (byte) 0x52, (byte) 0x0F, (byte) 0x68
+    };
+    static final byte[] alternativeHash7 = new byte[] {
+        (byte) 0x6B, (byte) 0xA2, (byte) 0xE9, (byte) 0x8E,
+        (byte) 0xE1, (byte) 0x8E, (byte) 0x60, (byte) 0xBE,
+        (byte) 0x54, (byte) 0xC4, (byte) 0x33, (byte) 0x3E,
+        (byte) 0x0C, (byte) 0x2D, (byte) 0x3A, (byte) 0x7C
+    };
+    static final byte[] alternativeHash8 = new byte[] {
+        (byte) 0xC1, (byte) 0x14, (byte) 0xE4, (byte) 0xC7,
+        (byte) 0x66, (byte) 0x21, (byte) 0x72, (byte) 0x77,
+        (byte) 0x70, (byte) 0x73, (byte) 0x84, (byte) 0x8B,
+        (byte) 0xFA, (byte) 0xF0, (byte) 0x1F, (byte) 0x9C
+    };
+
+    final static Map<String, byte[]> version2AlternativeHash = new HashMap<>();
+
+    static {
+        version2AlternativeHash.put("6", alternativeHash6);
+        version2AlternativeHash.put("7", alternativeHash7);
+        version2AlternativeHash.put("8", alternativeHash8);
+    }
+
+    public static void main(String... args) throws Exception {
+        if (args.length == 0) {
+            new ElementStructureTest().doTest();
+            return ;
+        }
+        switch (args[0]) {
+            case "generate-hashes":
+                new ElementStructureTest().generateHashes(args);
+                break;
+            case "generate-output":
+                new ElementStructureTest().generateOutput(args);
+                break;
+            default:
+                throw new IllegalStateException("Unrecognized request: " + args[0]);
+        }
+    }
+
+    void doTest() throws Exception {
+        for (PlatformProviderFactory fac : ServiceLoader.load(PlatformProviderFactory.class)) {
+            for (PlatformProvider provider : fac.createPlatformProviders()) {
+                String ver = provider.getName();
+                if (!version2AlternativeHash.containsKey(ver))
+                    continue;
+                try (ByteArrayOutputStream baos = new ByteArrayOutputStream(); Writer output = new OutputStreamWriter(baos, "UTF-8")) {
+                    run(output, ver);
+                    output.close();
+                    byte[] actual = MessageDigest.getInstance("MD5").digest(baos.toByteArray());
+                    if (!Arrays.equals(version2Hash.get(ver), actual) &&
+                        !Arrays.equals(version2AlternativeHash.get(ver), actual))
+                        throw new AssertionError("Wrong hash: " + toHex(actual) + " for version: " + ver);
+                }
+            }
+        }
+    }
+
+    void generateHashes(String... args) throws Exception {
+        Predicate<String> ignoreList = constructAcceptIgnoreList(args[1]);
+        for (int i = 2; i < args.length; i += 2) {
+            try (ByteArrayOutputStream baos = new ByteArrayOutputStream(); Writer output = new OutputStreamWriter(baos, "UTF-8")) {
+                realClasses(args[i], ignoreList, output, args[i + 1]);
+                output.close();
+                System.err.println("version:" + args[i + 1] + "; " + toHex(MessageDigest.getInstance("MD5").digest(baos.toByteArray())));
+            }
+        }
+    }
+
+    void generateOutput(String... args) throws Exception {
+        Predicate<String> ignoreList = constructAcceptIgnoreList(args[1]);
+        for (int i = 2; i < args.length; i += 4) {
+            try (Writer actual = Files.newBufferedWriter(Paths.get(args[i + 2]));
+                 Writer expected = Files.newBufferedWriter(Paths.get(args[i + 3]))) {
+                run(actual, args[i + 1]);
+                realClasses(args[i], ignoreList, expected, args[i + 1]);
+            }
+        }
+    }
+
+    Predicate<String> constructAcceptIgnoreList(String fromFiles) throws IOException {
+        StringBuilder acceptPattern = new StringBuilder();
+        StringBuilder rejectPattern = new StringBuilder();
+        for (String file : fromFiles.split(File.pathSeparator)) {
+            try (Stream<String> lines = Files.lines(Paths.get(file))) {
+                lines.forEach(line -> {
+                    if (line.isEmpty())
+                        return;
+                    StringBuilder targetPattern;
+                    switch (line.charAt(0)) {
+                        case '+':
+                            targetPattern = acceptPattern;
+                            break;
+                        case '-':
+                            targetPattern = rejectPattern;
+                            break;
+                        default:
+                            return ;
+                    }
+                    line = line.substring(1);
+                    if (line.endsWith("/")) {
+                        line += "[^/]*";
+                    } else {
+                        line += "|" + line + "$[^/]*";
+                    }
+                    line = line.replace("/", ".");
+                    if (targetPattern.length() != 0)
+                        targetPattern.append("|");
+                    targetPattern.append(line);
+                });
+            }
+        }
+        Pattern accept = Pattern.compile(acceptPattern.toString());
+        Pattern reject = Pattern.compile(rejectPattern.toString());
+
+        return clazzName -> accept.matcher(clazzName).matches() && !reject.matcher(clazzName).matches();
+    }
+
+    private static String toHex(byte[] bytes) {
+        StringBuilder hex = new StringBuilder();
+        String delim = "";
+
+        for (byte b : bytes) {
+            hex.append(delim);
+            hex.append(String.format("(byte) 0x%02X", b));
+            delim = ", ";
+        }
+
+        return hex.toString();
+    }
+
+    void run(Writer output, String version) throws Exception {
+        JavacTaskImpl task = (JavacTaskImpl) ToolProvider.getSystemJavaCompiler().getTask(null, null, null, Arrays.asList("-platform", version), null, Arrays.asList(new ToolBox.JavaSource("Test", "")));
+        task.parse();
+
+        JavaFileManager fm = task.getContext().get(JavaFileManager.class);
+
+        for (String pack : packages(fm)) {
+            PackageElement packEl = task.getElements().getPackageElement(pack);
+            if (packEl == null) {
+                throw new AssertionError("Cannot find package: " + pack);
+            }
+            new ExhaustiveElementScanner(task, output, p -> true).visit(packEl);
+        }
+    }
+
+    void realClasses(String location, Predicate<String> acceptor, Writer output, String version) throws Exception {
+        Path classes = Paths.get(location);
+        Map<String, JavaFileObject> className2File = new HashMap<>();
+        Map<JavaFileObject, String> file2ClassName = new HashMap<>();
+
+        try (BufferedReader descIn = Files.newBufferedReader(classes)) {
+            String classFileData;
+
+            while ((classFileData = descIn.readLine()) != null) {
+                ByteArrayOutputStream data = new ByteArrayOutputStream();
+                for (int i = 0; i < classFileData.length(); i += 2) {
+                    data.write(Integer.parseInt(classFileData.substring(i, i + 2), 16));
+                }
+                JavaFileObject file = new ByteArrayJavaFileObject(data.toByteArray());
+                try (InputStream in = new ByteArrayInputStream(data.toByteArray())) {
+                    String name = ClassFile.read(in).getName().replace("/", ".");
+                    className2File.put(name, file);
+                    file2ClassName.put(file, name);
+                } catch (IOException | ConstantPoolException ex) {
+                    throw new IllegalStateException(ex);
+                }
+            }
+        }
+
+        try (JavaFileManager fm = new TestFileManager(className2File, file2ClassName)) {
+            JavacTaskImpl task = (JavacTaskImpl) ToolProvider.getSystemJavaCompiler().getTask(null, fm, null, Arrays.asList("-source", version), null, Arrays.asList(new ToolBox.JavaSource("Test", "")));
+            task.parse();
+
+            PACK: for (String pack : packages(fm)) {
+                PackageElement packEl = task.getElements().getPackageElement(pack);
+                assert packEl != null;
+                new ExhaustiveElementScanner(task, output, acceptor).visit(packEl);
+            }
+        }
+    }
+
+    Set<String> packages(JavaFileManager fm) throws IOException {
+        Set<String> packages = new TreeSet<>();
+        EnumSet<Kind> kinds = EnumSet.of(JavaFileObject.Kind.CLASS, JavaFileObject.Kind.OTHER);
+
+        for (JavaFileObject file : fm.list(StandardLocation.PLATFORM_CLASS_PATH, "", kinds, true)) {
+            String binary = fm.inferBinaryName(StandardLocation.PLATFORM_CLASS_PATH, file);
+            packages.add(binary.substring(0, binary.lastIndexOf('.')));
+        }
+
+        return packages;
+    }
+
+    final class ExhaustiveElementScanner implements ElementVisitor<Void, Void> {
+
+        final JavacTask task;
+        final Writer out;
+        final Predicate<String> acceptType;
+
+        public ExhaustiveElementScanner(JavacTask task, Writer out, Predicate<String> acceptType) {
+            this.task = task;
+            this.out = out;
+            this.acceptType = acceptType;
+        }
+
+        @Override
+        public Void visit(Element e, Void p) {
+            return e.accept(this, p);
+        }
+
+        @Override
+        public Void visit(Element e) {
+            return e.accept(this, null);
+        }
+
+        private void write(TypeMirror type) throws IOException {
+            try {
+                out.write(type.toString()
+                              .replace("java.lang.invoke.MethodHandle$PolymorphicSignature", "java.lang.invoke.MethodHandle.PolymorphicSignature")
+                              .replace("javax.swing.JRootPane$DefaultAction", "javax.swing.JRootPane.DefaultAction")
+                              .replace("javax.swing.plaf.metal.MetalFileChooserUI$DirectoryComboBoxRenderer", "javax.swing.plaf.metal.MetalFileChooserUI.DirectoryComboBoxRenderer")
+                         );
+            } catch (CompletionFailure cf) {
+                out.write("cf");
+            }
+        }
+
+        private void writeTypes(Iterable<? extends TypeMirror> types) throws IOException {
+            String sep = "";
+
+            for (TypeMirror type : types) {
+                out.write(sep);
+                write(type);
+                sep = ", ";
+            }
+        }
+
+        private void writeAnnotations(Iterable<? extends AnnotationMirror> annotations) throws IOException {
+            for (AnnotationMirror ann : annotations) {
+                out.write("@");
+                write(ann.getAnnotationType());
+                if (!ann.getElementValues().isEmpty()) {
+                    out.write("(");
+                    Map<ExecutableElement, AnnotationValue> valuesMap = new TreeMap<>((a1, a2) -> a1.getSimpleName().toString().compareTo(a2.getSimpleName().toString()));
+                    valuesMap.putAll(ann.getElementValues());
+                    for (Entry<? extends ExecutableElement, ? extends AnnotationValue> ev : valuesMap.entrySet()) {
+                        out.write(ev.getKey().getSimpleName().toString());
+                        out.write(" = ");
+                        out.write(ev.getValue().toString());
+                    }
+                    out.write(")");
+                }
+            }
+        }
+
+        void analyzeElement(Element e) {
+            try {
+                write(e.asType());
+                writeAnnotations(e.getAnnotationMirrors());
+                out.write(e.getKind().toString());
+                out.write(e.getModifiers().toString());
+                out.write(e.getSimpleName().toString());
+            } catch (IOException ex) {
+                ex.printStackTrace();
+            }
+        }
+
+        boolean acceptAccess(Element e) {
+            return e.getModifiers().contains(Modifier.PUBLIC) || e.getModifiers().contains(Modifier.PROTECTED);
+        }
+
+        @Override
+        public Void visitExecutable(ExecutableElement e, Void p) {
+            if (!acceptAccess(e))
+                return null;
+            try {
+                analyzeElement(e);
+                out.write(String.valueOf(e.getDefaultValue()));
+                for (VariableElement param : e.getParameters()) {
+                    visit(param, p);
+                }
+                out.write(String.valueOf(e.getReceiverType()));
+                write(e.getReturnType());
+                out.write(e.getSimpleName().toString());
+                writeTypes(e.getThrownTypes());
+                for (TypeParameterElement param : e.getTypeParameters()) {
+                    visit(param, p);
+                }
+                out.write(String.valueOf(e.isDefault()));
+                out.write(String.valueOf(e.isVarArgs()));
+                out.write("\n");
+            } catch (IOException ex) {
+                ex.printStackTrace();
+            }
+            return null;
+        }
+
+        @Override
+        public Void visitPackage(PackageElement e, Void p) {
+            List<Element> types = new ArrayList<>(e.getEnclosedElements());
+            Collections.sort(types, (e1, e2) -> e1.getSimpleName().toString().compareTo(e2.getSimpleName().toString()));
+            for (Element encl : types) {
+                visit(encl, p);
+            }
+            return null;
+        }
+
+        @Override
+        public Void visitType(TypeElement e, Void p) {
+            if (!acceptAccess(e))
+                return null;
+            writeType(e);
+            return null;
+        }
+
+        void writeType(TypeElement e) {
+            if (!acceptType.test(task.getElements().getBinaryName(e).toString()))
+                return ;
+            try {
+                analyzeElement(e);
+                writeTypes(e.getInterfaces());
+                out.write(e.getNestingKind().toString());
+                out.write(e.getQualifiedName().toString());
+                write(e.getSuperclass());
+                for (TypeParameterElement param : e.getTypeParameters()) {
+                    visit(param, null);
+                }
+                List<Element> defs = new ArrayList<>(e.getEnclosedElements()); //XXX: forcing ordering for members - not completely correct!
+                Collections.sort(defs, (e1, e2) -> e1.toString().compareTo(e2.toString()));
+                for (Element def : defs) {
+                    visit(def, null);
+                }
+                out.write("\n");
+            } catch (IOException ex) {
+                ex.printStackTrace();
+            }
+        }
+
+        @Override
+        public Void visitVariable(VariableElement e, Void p) {
+            if (!acceptAccess(e))
+                return null;
+            try {
+                analyzeElement(e);
+                out.write(String.valueOf(e.getConstantValue()));
+                out.write("\n");
+            } catch (IOException ex) {
+                ex.printStackTrace();
+            }
+            return null;
+        }
+
+        @Override
+        public Void visitTypeParameter(TypeParameterElement e, Void p) {
+            try {
+                analyzeElement(e);
+                out.write(e.getBounds().toString());
+                out.write("\n");
+            } catch (IOException ex) {
+                ex.printStackTrace();
+            }
+            return null;
+        }
+
+        @Override
+        public Void visitUnknown(Element e, Void p) {
+            throw new IllegalStateException("Should not get here.");
+        }
+        
+    }
+
+    final class TestFileManager implements JavaFileManager {
+
+        final Map<String, JavaFileObject> className2File;
+        final Map<JavaFileObject, String> file2ClassName;
+
+        public TestFileManager(Map<String, JavaFileObject> className2File, Map<JavaFileObject, String> file2ClassName) {
+            this.className2File = className2File;
+            this.file2ClassName = file2ClassName;
+        }
+
+        @Override
+        public ClassLoader getClassLoader(Location location) {
+            return new URLClassLoader(new URL[0]);
+        }
+
+        @Override
+        public Iterable<JavaFileObject> list(Location location, String packageName, Set<Kind> kinds, boolean recurse) throws IOException {
+            if (location != StandardLocation.PLATFORM_CLASS_PATH || !kinds.contains(Kind.CLASS))
+                return Collections.emptyList();
+
+            if (!packageName.isEmpty())
+                packageName += ".";
+
+            List<JavaFileObject> result = new ArrayList<>();
+
+            for (Entry<String, JavaFileObject> e : className2File.entrySet()) {
+                String currentPackage = e.getKey().substring(0, e.getKey().lastIndexOf(".") + 1);
+                if (recurse ? currentPackage.startsWith(packageName) : packageName.equals(currentPackage))
+                    result.add(e.getValue());
+            }
+
+            return result;
+        }
+
+        @Override
+        public String inferBinaryName(Location location, JavaFileObject file) {
+            return file2ClassName.get(file);
+        }
+
+        @Override
+        public boolean isSameFile(FileObject a, FileObject b) {
+            return a == b;
+        }
+
+        @Override
+        public boolean handleOption(String current, Iterator<String> remaining) {
+            return false;
+        }
+
+        @Override
+        public boolean hasLocation(Location location) {
+            return location == StandardLocation.PLATFORM_CLASS_PATH;
+        }
+
+        @Override
+        public JavaFileObject getJavaFileForInput(Location location, String className, Kind kind) throws IOException {
+            if (location != StandardLocation.PLATFORM_CLASS_PATH || kind != Kind.CLASS)
+                return null;
+
+            return className2File.get(className);
+        }
+
+        @Override
+        public JavaFileObject getJavaFileForOutput(Location location, String className, Kind kind, FileObject sibling) throws IOException {
+            throw new UnsupportedOperationException("");
+        }
+
+        @Override
+        public FileObject getFileForInput(Location location, String packageName, String relativeName) throws IOException {
+            return null;
+        }
+
+        @Override
+        public FileObject getFileForOutput(Location location, String packageName, String relativeName, FileObject sibling) throws IOException {
+            throw new UnsupportedOperationException("");
+        }
+
+        @Override
+        public void flush() throws IOException {
+        }
+
+        @Override
+        public void close() throws IOException {
+        }
+
+        @Override
+        public int isSupportedOption(String option) {
+            return -1;
+        }
+
+    }
+
+    static class ByteArrayJavaFileObject implements JavaFileObject {
+
+        private final byte[] data;
+
+        public ByteArrayJavaFileObject(byte[] data) {
+            this.data = data;
+        }
+
+        @Override
+        public Kind getKind() {
+            return Kind.CLASS;
+        }
+
+        @Override
+        public boolean isNameCompatible(String simpleName, Kind kind) {
+            return true;
+        }
+
+        @Override
+        public NestingKind getNestingKind() {
+            return null;
+        }
+
+        @Override
+        public Modifier getAccessLevel() {
+            return null;
+        }
+
+        @Override
+        public URI toUri() {
+            return null;
+        }
+
+        @Override
+        public String getName() {
+            return null;
+        }
+
+        @Override
+        public InputStream openInputStream() throws IOException {
+            return new ByteArrayInputStream(data);
+        }
+
+        @Override
+        public OutputStream openOutputStream() throws IOException {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public Reader openReader(boolean ignoreEncodingErrors) throws IOException {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public Writer openWriter() throws IOException {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public long getLastModified() {
+            return 0;
+        }
+
+        @Override
+        public boolean delete() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+}
diff --git a/test/tools/lib/ToolBox.java b/test/tools/lib/ToolBox.java
--- a/test/tools/lib/ToolBox.java
+++ b/test/tools/lib/ToolBox.java
@@ -754,7 +754,7 @@
                 try {
                     String line;
                     while ((line = in.readLine()) != null) {
-                        out.append(line).append("\n");
+                        out.append(line).append(lineSeparator);
                     }
                 } catch (IOException e) {
                 }