Mercurial > hg > graal-jvmci-8
diff src/share/tools/MakeDeps/BuildConfig.java @ 0:a61af66fc99e jdk7-b24
Initial load
author | duke |
---|---|
date | Sat, 01 Dec 2007 00:00:00 +0000 |
parents | |
children | 82e4d969e7cb |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/MakeDeps/BuildConfig.java Sat Dec 01 00:00:00 2007 +0000 @@ -0,0 +1,706 @@ +/* + * Copyright 2005-2006 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +import java.util.*; +import java.io.File; + +class BuildConfig { + Hashtable vars; + Vector basicNames, basicPaths; + String[] context; + + static CompilerInterface ci; + static CompilerInterface getCI() { + if (ci == null) { + String comp = (String)getField(null, "CompilerVersion"); + try { + ci = (CompilerInterface)Class.forName("CompilerInterface" + comp).newInstance(); + } catch (Exception cnfe) { + System.err.println("Cannot find support for compiler " + comp); + throw new RuntimeException(cnfe.toString()); + } + } + return ci; + } + + protected void initNames(String flavour, String build, String outDll) { + if (vars == null) vars = new Hashtable(); + + String flavourBuild = flavour + "_" + build; + put("Name", getCI().makeCfgName(flavourBuild)); + put("Flavour", flavour); + put("Build", build); + + // ones mentioned above were needed to expand format + String buildBase = expandFormat(getFieldString(null, "BuildBase")); + String jdkDir = getFieldString(null, "JdkTargetRoot"); + String sourceBase = getFieldString(null, "SourceBase"); + String outDir = buildBase; + + put("Id", flavourBuild); + put("OutputDir", outDir); + put("SourceBase", sourceBase); + put("BuildBase", buildBase); + put("OutputDll", jdkDir + Util.sep + outDll); + + context = new String [] {flavourBuild, flavour, build, null}; + } + + protected void init(Vector includes, Vector defines) { + initDefaultDefines(defines); + initDefaultCompilerFlags(includes); + initDefaultLinkerFlags(); + handleDB((String)getFieldInContext("IncludeDB")); + } + + + protected void initDefaultCompilerFlags(Vector includes) { + Vector compilerFlags = new Vector(); + + compilerFlags.addAll(getCI().getBaseCompilerFlags(getV("Define"), + includes, + get("OutputDir"))); + + put("CompilerFlags", compilerFlags); + } + + protected void initDefaultLinkerFlags() { + Vector linkerFlags = new Vector(); + + linkerFlags.addAll(getCI().getBaseLinkerFlags( get("OutputDir"), get("OutputDll"))); + + put("LinkerFlags", linkerFlags); + } + + DirectoryTree getSourceTree(String sourceBase, String startAt) { + DirectoryTree tree = new DirectoryTree(); + + tree.addSubdirToIgnore("Codemgr_wsdata"); + tree.addSubdirToIgnore("deleted_files"); + tree.addSubdirToIgnore("SCCS"); + tree.setVerbose(true); + if (startAt != null) { + tree.readDirectory(sourceBase + File.separator + startAt); + } else { + tree.readDirectory(sourceBase); + } + + return tree; + } + + + Vector getPreferredPaths(Database currentDB) { + Vector preferredPaths = new Vector(); + // In the case of multiple files with the same name in + // different subdirectories, prefer the versions specified in + // the platform file as the "os_family" and "arch" macros. + for (Iterator iter = currentDB.getMacros(); iter.hasNext(); ) { + Macro macro = (Macro) iter.next(); + if (macro.name.equals("os_family") || + macro.name.equals("arch")) { + preferredPaths.add(macro.contents); + } + } + // Also prefer "opto" over "adlc" for adlcVMDeps.hpp + preferredPaths.add("opto"); + + return preferredPaths; + } + + + void handleDB(String dbFile) { + WinGammaPlatform platform = (WinGammaPlatform)getField(null, "PlatformObject"); + Database db = new Database(platform, platform.defaultGrandIncludeThreshold()); + + try { + File incls = new File(get("OutputDir")+Util.sep+"incls"); + FileName oldInclTempl = platform.getInclFileTemplate(); + FileName oldGITempl = platform.getGIFileTemplate(); + FileName oldGDTempl = platform.getGDFileTemplate(); + + platform.setInclFileTemplate(new FileName(platform, incls.getPath()+Util.sep, + "_", "", ".incl", "", "")); + platform.setGIFileTemplate(new FileName(platform, incls.getPath()+Util.sep, + "", "_precompiled", ".incl", "", "")); + + incls.mkdirs(); + + db.get(getFieldString(null, "Platform"), dbFile); + db.compute(); + + db.put(); + + //platform.setInclFileTemplate(oldInclTempl); + //platform.setGIFileTemplate(oldInclTempl); + } catch (Exception e) { + e.printStackTrace(); + throw new RuntimeException("cannot do db: "+e); + } + + putSpecificField("AllFilesHash", computeAllFiles(platform, db)); + } + + + void addAll(Iterator i, Hashtable hash, + WinGammaPlatform platform, DirectoryTree tree, + Vector preferredPaths, Vector filesNotFound, Vector filesDuplicate) { + for (; i.hasNext(); ) { + String fileName = (String) i.next(); + if (lookupHashFieldInContext("IgnoreFile", fileName) == null) { + String prefixedName = platform.envVarPrefixedFileName(fileName, + 0, /* ignored */ + tree, + preferredPaths, + filesNotFound, + filesDuplicate); + if (prefixedName != null) { + addTo(hash, Util.normalize(prefixedName), fileName); + } + } + } + } + + void addTo(Hashtable ht, String key, String value) { + ht.put(expandFormat(key), expandFormat(value)); + } + + Hashtable computeAllFiles(WinGammaPlatform platform, Database db) { + Hashtable rv = new Hashtable(); + DirectoryTree tree = getSourceTree(get("SourceBase"), getFieldString(null, "StartAt")); + Vector preferredPaths = getPreferredPaths(db); + + // Hold errors until end + Vector filesNotFound = new Vector(); + Vector filesDuplicate = new Vector(); + + + // find all files + Vector dbFiles = new Vector(); + for (Iterator i=db.getAllFiles().iterator(); i.hasNext(); ) { + FileList fl = (FileList) i.next(); + dbFiles.add(fl.getName()); + } + addAll(dbFiles.iterator(), rv, + platform, tree, + preferredPaths, filesNotFound, filesDuplicate); + + Vector addFiles = new Vector(); + collectRelevantVectors(addFiles, "AdditionalFile"); + addAll(addFiles.iterator(), rv, + platform, tree, + preferredPaths, filesNotFound, filesDuplicate); + + collectRelevantHashes(rv, "AdditionalGeneratedFile"); + + if ((filesNotFound.size() != 0) || + (filesDuplicate.size() != 0)) { + System.err.println("Error: some files were not found or " + + "appeared in multiple subdirectories of " + + "directory " + get("SourceBase") + " and could not " + + "be resolved with the os_family and arch " + + "macros in the platform file."); + if (filesNotFound.size() != 0) { + System.err.println("Files not found:"); + for (Iterator iter = filesNotFound.iterator(); + iter.hasNext(); ) { + System.err.println(" " + (String) iter.next()); + } + } + if (filesDuplicate.size() != 0) { + System.err.println("Duplicate files:"); + for (Iterator iter = filesDuplicate.iterator(); + iter.hasNext(); ) { + System.err.println(" " + (String) iter.next()); + } + } + throw new RuntimeException(); + } + + return rv; + } + + void initDefaultDefines(Vector defines) { + Vector sysDefines = new Vector(); + sysDefines.add("WIN32"); + sysDefines.add("_WINDOWS"); + sysDefines.add("HOTSPOT_BUILD_USER="+System.getProperty("user.name")); + sysDefines.add("HOTSPOT_BUILD_TARGET=\\\""+get("Build")+"\\\""); + sysDefines.add("_JNI_IMPLEMENTATION_"); + + sysDefines.addAll(defines); + + put("Define", sysDefines); + } + + String get(String key) { + return (String)vars.get(key); + } + + Vector getV(String key) { + return (Vector)vars.get(key); + } + + Object getO(String key) { + return vars.get(key); + } + + Hashtable getH(String key) { + return (Hashtable)vars.get(key); + } + + Object getFieldInContext(String field) { + for (int i=0; i<context.length; i++) { + Object rv = getField(context[i], field); + if (rv != null) { + return rv; + } + } + return null; + } + + Object lookupHashFieldInContext(String field, String key) { + for (int i=0; i<context.length; i++) { + Hashtable ht = (Hashtable)getField(context[i], field); + if (ht != null) { + Object rv = ht.get(key); + if (rv != null) { + return rv; + } + } + } + return null; + } + + void put(String key, String value) { + vars.put(key, value); + } + + void put(String key, Vector vvalue) { + vars.put(key, vvalue); + } + + void add(String key, Vector vvalue) { + getV(key).addAll(vvalue); + } + + String flavour() { + return get("Flavour"); + } + + String build() { + return get("Build"); + } + + Object getSpecificField(String field) { + return getField(get("Id"), field); + } + + void putSpecificField(String field, Object value) { + putField(get("Id"), field, value); + } + + void collectRelevantVectors(Vector rv, String field) { + for (int i = 0; i < context.length; i++) { + Vector v = getFieldVector(context[i], field); + if (v != null) { + for (Iterator j=v.iterator(); j.hasNext(); ) { + String val = (String)j.next(); + rv.add(expandFormat(val)); + } + } + } + } + + void collectRelevantHashes(Hashtable rv, String field) { + for (int i = 0; i < context.length; i++) { + Hashtable v = (Hashtable)getField(context[i], field); + if (v != null) { + for (Enumeration e=v.keys(); e.hasMoreElements(); ) { + String key = (String)e.nextElement(); + String val = (String)v.get(key); + addTo(rv, key, val); + } + } + } + } + + + Vector getDefines() { + Vector rv = new Vector(); + collectRelevantVectors(rv, "Define"); + return rv; + } + + Vector getIncludes() { + Vector rv = new Vector(); + + // for generated includes + rv.add(get("OutputDir")); + + collectRelevantVectors(rv, "AbsoluteInclude"); + + Vector ri = new Vector(); + String sourceBase = getFieldString(null, "SourceBase"); + collectRelevantVectors(ri, "RelativeInclude"); + for (Iterator i = ri.iterator(); i.hasNext(); ) { + String f = (String)i.next(); + rv.add(sourceBase + Util.sep + f); + } + + return rv; + } + + static Hashtable cfgData = new Hashtable(); + static Hashtable globalData = new Hashtable(); + + static boolean appliesToTieredBuild(String cfg) { + return (cfg != null && + (cfg.startsWith("compiler1") || + cfg.startsWith("compiler2"))); + } + + // Filters out the IncludeDB statement, which is the only command- + // line argument we explicitly specialize for the tiered build + static boolean appliesToTieredBuild(String cfg, String key) { + return (appliesToTieredBuild(cfg) && + (key != null && + !key.equals("IncludeDB"))); + } + + static String getTieredBuildCfg(String cfg) { + assert appliesToTieredBuild(cfg) : "illegal configuration " + cfg; + return "tiered" + cfg.substring(9); + } + + static Object getField(String cfg, String field) { + if (cfg == null) { + return globalData.get(field); + } + + Hashtable ht = (Hashtable)cfgData.get(cfg); + return ht == null ? null : ht.get(field); + } + + static String getFieldString(String cfg, String field) { + return (String)getField(cfg, field); + } + + static Vector getFieldVector(String cfg, String field) { + return (Vector)getField(cfg, field); + } + + static void putField(String cfg, String field, Object value) { + putFieldImpl(cfg, field, value); + if (appliesToTieredBuild(cfg, field)) { + putFieldImpl(getTieredBuildCfg(cfg), field, value); + } + } + + private static void putFieldImpl(String cfg, String field, Object value) { + if (cfg == null) { + globalData.put(field, value); + return; + } + + Hashtable ht = (Hashtable)cfgData.get(cfg); + if (ht == null) { + ht = new Hashtable(); + cfgData.put(cfg, ht); + } + + ht.put(field, value); + } + + static Object getFieldHash(String cfg, String field, String name) { + Hashtable ht = (Hashtable)getField(cfg, field); + + return ht == null ? null : ht.get(name); + } + + static void putFieldHash(String cfg, String field, String name, Object val) { + putFieldHashImpl(cfg, field, name, val); + if (appliesToTieredBuild(cfg)) { + putFieldHashImpl(getTieredBuildCfg(cfg), field, name, val); + } + } + + private static void putFieldHashImpl(String cfg, String field, String name, Object val) { + Hashtable ht = (Hashtable)getField(cfg, field); + + if (ht == null) { + ht = new Hashtable(); + putFieldImpl(cfg, field, ht); + } + + ht.put(name, val); + } + + static void addFieldVector(String cfg, String field, String element) { + addFieldVectorImpl(cfg, field, element); + if (appliesToTieredBuild(cfg)) { + addFieldVectorImpl(getTieredBuildCfg(cfg), field, element); + } + } + + private static void addFieldVectorImpl(String cfg, String field, String element) { + Vector v = (Vector)getField(cfg, field); + + if (v == null) { + v = new Vector(); + putFieldImpl(cfg, field, v); + } + + v.add(element); + } + + String expandFormat(String format) { + if (format == null) { + return null; + } + + if (format.indexOf('%') == -1) { + return format; + } + + StringBuffer sb = new StringBuffer(); + int len = format.length(); + for (int i=0; i<len; i++) { + char ch = format.charAt(i); + if (ch == '%') { + char ch1 = format.charAt(i+1); + switch (ch1) { + case '%': + sb.append(ch1); + break; + case 'b': + sb.append(build()); + break; + case 'f': + sb.append(flavour()); + break; + default: + sb.append(ch); + sb.append(ch1); + } + i++; + } else { + sb.append(ch); + } + } + + return sb.toString(); + } +} + +abstract class GenericDebugConfig extends BuildConfig { + abstract String getOptFlag(); + + protected void init(Vector includes, Vector defines) { + defines.add("_DEBUG"); + defines.add("ASSERT"); + + super.init(includes, defines); + + getV("CompilerFlags").addAll(getCI().getDebugCompilerFlags(getOptFlag())); + getV("LinkerFlags").addAll(getCI().getDebugLinkerFlags()); + } +} + +class C1DebugConfig extends GenericDebugConfig { + String getOptFlag() { + return getCI().getNoOptFlag(); + } + + C1DebugConfig() { + initNames("compiler1", "debug", "fastdebug\\jre\\bin\\client\\jvm.dll"); + init(getIncludes(), getDefines()); + } +} + +class C1FastDebugConfig extends GenericDebugConfig { + String getOptFlag() { + return getCI().getOptFlag(); + } + + C1FastDebugConfig() { + initNames("compiler1", "fastdebug", "fastdebug\\jre\\bin\\client\\jvm.dll"); + init(getIncludes(), getDefines()); + } +} + +class C2DebugConfig extends GenericDebugConfig { + String getOptFlag() { + return getCI().getNoOptFlag(); + } + + C2DebugConfig() { + initNames("compiler2", "debug", "fastdebug\\jre\\bin\\server\\jvm.dll"); + init(getIncludes(), getDefines()); + } +} + +class C2FastDebugConfig extends GenericDebugConfig { + String getOptFlag() { + return getCI().getOptFlag(); + } + + C2FastDebugConfig() { + initNames("compiler2", "fastdebug", "fastdebug\\jre\\bin\\server\\jvm.dll"); + init(getIncludes(), getDefines()); + } +} + +class TieredDebugConfig extends GenericDebugConfig { + String getOptFlag() { + return getCI().getNoOptFlag(); + } + + TieredDebugConfig() { + initNames("tiered", "debug", "fastdebug\\jre\\bin\\server\\jvm.dll"); + init(getIncludes(), getDefines()); + } +} + +class TieredFastDebugConfig extends GenericDebugConfig { + String getOptFlag() { + return getCI().getOptFlag(); + } + + TieredFastDebugConfig() { + initNames("tiered", "fastdebug", "fastdebug\\jre\\bin\\server\\jvm.dll"); + init(getIncludes(), getDefines()); + } +} + + +abstract class ProductConfig extends BuildConfig { + protected void init(Vector includes, Vector defines) { + defines.add("NDEBUG"); + defines.add("PRODUCT"); + + super.init(includes, defines); + + getV("CompilerFlags").addAll(getCI().getProductCompilerFlags()); + getV("LinkerFlags").addAll(getCI().getProductLinkerFlags()); + } +} + +class C1ProductConfig extends ProductConfig { + C1ProductConfig() { + initNames("compiler1", "product", "jre\\bin\\client\\jvm.dll"); + init(getIncludes(), getDefines()); + } +} + +class C2ProductConfig extends ProductConfig { + C2ProductConfig() { + initNames("compiler2", "product", "jre\\bin\\server\\jvm.dll"); + init(getIncludes(), getDefines()); + } +} + +class TieredProductConfig extends ProductConfig { + TieredProductConfig() { + initNames("tiered", "product", "jre\\bin\\server\\jvm.dll"); + init(getIncludes(), getDefines()); + } +} + + +class CoreDebugConfig extends GenericDebugConfig { + String getOptFlag() { + return getCI().getNoOptFlag(); + } + + CoreDebugConfig() { + initNames("core", "debug", "fastdebug\\jre\\bin\\core\\jvm.dll"); + init(getIncludes(), getDefines()); + } +} + + +class CoreFastDebugConfig extends GenericDebugConfig { + String getOptFlag() { + return getCI().getOptFlag(); + } + + CoreFastDebugConfig() { + initNames("core", "fastdebug", "fastdebug\\jre\\bin\\core\\jvm.dll"); + init(getIncludes(), getDefines()); + } +} + + +class CoreProductConfig extends ProductConfig { + CoreProductConfig() { + initNames("core", "product", "jre\\bin\\core\\jvm.dll"); + init(getIncludes(), getDefines()); + } +} + +class KernelDebugConfig extends GenericDebugConfig { + String getOptFlag() { + return getCI().getNoOptFlag(); + } + + KernelDebugConfig() { + initNames("kernel", "debug", "fastdebug\\jre\\bin\\kernel\\jvm.dll"); + init(getIncludes(), getDefines()); + } +} + + +class KernelFastDebugConfig extends GenericDebugConfig { + String getOptFlag() { + return getCI().getOptFlag(); + } + + KernelFastDebugConfig() { + initNames("kernel", "fastdebug", "fastdebug\\jre\\bin\\kernel\\jvm.dll"); + init(getIncludes(), getDefines()); + } +} + + +class KernelProductConfig extends ProductConfig { + KernelProductConfig() { + initNames("kernel", "product", "jre\\bin\\kernel\\jvm.dll"); + init(getIncludes(), getDefines()); + } +} +abstract class CompilerInterface { + abstract Vector getBaseCompilerFlags(Vector defines, Vector includes, String outDir); + abstract Vector getBaseLinkerFlags(String outDir, String outDll); + abstract Vector getDebugCompilerFlags(String opt); + abstract Vector getDebugLinkerFlags(); + abstract Vector getProductCompilerFlags(); + abstract Vector getProductLinkerFlags(); + abstract String getOptFlag(); + abstract String getNoOptFlag(); + abstract String makeCfgName(String flavourBuild); + + void addAttr(Vector receiver, String attr, String value) { + receiver.add(attr); receiver.add(value); + } +}