jdk8-mips64-public/hotspot: src/share/tools/ProjectCreator/BuildConfig.java@f95d63e2154a

6989984: Use standard include model for Hospot
Summary: Replaced MakeDeps and the includeDB files with more standardized solutions.
Reviewed-by: coleenp, kvn, kamg

     1 /*

     2  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    25 import java.util.*;

    26 import java.io.File;

    28 class BuildConfig {

    29     Hashtable vars;

    30     Vector basicNames, basicPaths;

    31     String[] context;

    33     static CompilerInterface ci;

    34     static CompilerInterface getCI() {

    35         if (ci == null) {

    36             String comp = (String)getField(null, "CompilerVersion");

    37             try {

    38                 ci = (CompilerInterface)Class.forName("CompilerInterface" + comp).newInstance();

    39             } catch (Exception cnfe) {

    40                 System.err.println("Cannot find support for compiler " + comp);

    41                 throw new RuntimeException(cnfe.toString());

    42             }

    43         }

    44         return ci;

    45     }

    47     protected void initNames(String flavour, String build, String outDll) {

    48         if (vars == null) vars = new Hashtable();

    50         String flavourBuild =  flavour + "_" + build;

    51         System.out.println();

    52         System.out.println(flavourBuild);

    54         put("Name", getCI().makeCfgName(flavourBuild));

    55         put("Flavour", flavour);

    56         put("Build", build);

    58         // ones mentioned above were needed to expand format

    59         String buildBase = expandFormat(getFieldString(null, "BuildBase"));

    60         String jdkDir =  getFieldString(null, "JdkTargetRoot");

    61         String sourceBase = getFieldString(null, "SourceBase");

    62         String outDir = buildBase;

    64         put("Id", flavourBuild);

    65         put("OutputDir", outDir);

    66         put("SourceBase", sourceBase);

    67         put("BuildBase", buildBase);

    68         put("OutputDll", jdkDir + Util.sep + outDll);

    70         context = new String [] {flavourBuild, flavour, build, null};

    71     }

    73     protected void init(Vector includes, Vector defines) {

    74         initDefaultDefines(defines);

    75         initDefaultCompilerFlags(includes);

    76         initDefaultLinkerFlags();

    77         handleDB();

    78     }

    81     protected void initDefaultCompilerFlags(Vector includes) {

    82         Vector compilerFlags = new Vector();

    84         compilerFlags.addAll(getCI().getBaseCompilerFlags(getV("Define"),

    85                                                           includes,

    86                                                           get("OutputDir")));

    88         put("CompilerFlags", compilerFlags);

    89     }

    91     protected void initDefaultLinkerFlags() {

    92         Vector linkerFlags = new Vector();

    94         linkerFlags.addAll(getCI().getBaseLinkerFlags( get("OutputDir"), get("OutputDll")));

    96         put("LinkerFlags", linkerFlags);

    97     }

    99     DirectoryTree getSourceTree(String sourceBase, String startAt) {

   100         DirectoryTree tree = new DirectoryTree();

   102         tree.addSubdirToIgnore("Codemgr_wsdata");

   103         tree.addSubdirToIgnore("deleted_files");

   104         tree.addSubdirToIgnore("SCCS");

   105         tree.setVerbose(true);

   106         if (startAt != null) {

   107             tree.readDirectory(sourceBase + File.separator + startAt);

   108         } else {

   109             tree.readDirectory(sourceBase);

   110         }

   112         return tree;

   113     }

   116     Vector getPreferredPaths(MacroDefinitions macros) {

   117         Vector preferredPaths = new Vector();

   118         // In the case of multiple files with the same name in

   119         // different subdirectories, prefer the versions specified in

   120         // the platform file as the "os_family" and "arch" macros.

   121         for (Iterator iter = macros.getMacros(); iter.hasNext(); ) {

   122             Macro macro = (Macro) iter.next();

   123             if (macro.name.equals("os_family") ||

   124                 macro.name.equals("arch")) {

   125                 preferredPaths.add(macro.contents);

   126             }

   127         }

   128         // Also prefer "opto" over "adlc" for adlcVMDeps.hpp

   129         preferredPaths.add("opto");

   131         return preferredPaths;

   132     }

   135     void handleDB() {

   136         WinGammaPlatform platform = (WinGammaPlatform)getField(null, "PlatformObject");

   138         File incls = new File(get("OutputDir")+Util.sep+"incls");

   140         incls.mkdirs();

   142         MacroDefinitions macros = new MacroDefinitions();

   143         try {

   144             macros.readFrom(getFieldString(null, "Platform"), false);

   145         } catch (Exception e) {

   146             throw new RuntimeException(e);

   147         }

   149         putSpecificField("AllFilesHash", computeAllFiles(platform, macros));

   150     }

   153     private boolean matchesIgnoredPath(String prefixedName) {

   154         Vector rv = new Vector();

   155         collectRelevantVectors(rv, "IgnorePath");

   156         for (Iterator i = rv.iterator(); i.hasNext(); ) {

   157             String pathPart = (String) i.next();

   158             if (prefixedName.contains(Util.normalize(pathPart)))  {

   159                 return true;

   160             }

   161         }

   162         return false;

   163     }

   165     void addAll(Iterator i, Hashtable hash,

   166                 WinGammaPlatform platform, DirectoryTree tree,

   167                 Vector preferredPaths, Vector filesNotFound, Vector filesDuplicate) {

   168         for (; i.hasNext(); ) {

   169             String fileName = (String) i.next();

   170             if (lookupHashFieldInContext("IgnoreFile", fileName) == null) {

   171                 String prefixedName = platform.envVarPrefixedFileName(fileName,

   172                                                                       0, /* ignored */

   173                                                                       tree,

   174                                                                       preferredPaths,

   175                                                                       filesNotFound,

   176                                                                       filesDuplicate);

   177                 if (prefixedName != null) {

   178                     prefixedName = Util.normalize(prefixedName);

   179                     if (!matchesIgnoredPath(prefixedName)) {

   180                         addTo(hash, prefixedName, fileName);

   181                     }

   182                 }

   183             }

   184         }

   185     }

   187     void addTo(Hashtable ht, String key, String value) {

   188         ht.put(expandFormat(key), expandFormat(value));

   189     }

   191     Hashtable computeAllFiles(WinGammaPlatform platform, MacroDefinitions macros) {

   192         Hashtable rv = new Hashtable();

   193         DirectoryTree tree = getSourceTree(get("SourceBase"), getFieldString(null, "StartAt"));

   194         Vector preferredPaths = getPreferredPaths(macros);

   196         // Hold errors until end

   197         Vector filesNotFound = new Vector();

   198         Vector filesDuplicate = new Vector();

   200         Vector includedFiles = new Vector();

   202         // find all files

   203         Vector dirs = getSourceIncludes();

   204         for (Iterator i = dirs.iterator(); i.hasNext(); ) {

   205             String dir = (String)i.next();

   206             DirectoryTree subtree = getSourceTree(dir, null);

   207             for (Iterator fi = subtree.getFileIterator(); fi.hasNext(); ) {

   208                 String name = ((File)fi.next()).getName();

   209                 includedFiles.add(name);

   210             }

   211         }

   212         addAll(includedFiles.iterator(), rv,

   213                platform, tree,

   214                preferredPaths, filesNotFound, filesDuplicate);

   216         Vector addFiles = new Vector();

   217         collectRelevantVectors(addFiles, "AdditionalFile");

   218         addAll(addFiles.iterator(), rv,

   219                platform, tree,

   220                preferredPaths, filesNotFound, filesDuplicate);

   222         collectRelevantHashes(rv, "AdditionalGeneratedFile");

   224         if ((filesNotFound.size() != 0) ||

   225             (filesDuplicate.size() != 0)) {

   226             System.err.println("Error: some files were not found or " +

   227                                "appeared in multiple subdirectories of " +

   228                                "directory " + get("SourceBase") + " and could not " +

   229                                "be resolved with the os_family and arch " +

   230                                "macros in the platform file.");

   231             if (filesNotFound.size() != 0) {

   232                 System.err.println("Files not found:");

   233                 for (Iterator iter = filesNotFound.iterator();

   234                      iter.hasNext(); ) {

   235                     System.err.println("  " + (String) iter.next());

   236                 }

   237             }

   238             if (filesDuplicate.size() != 0) {

   239                 System.err.println("Duplicate files:");

   240                 for (Iterator iter = filesDuplicate.iterator();

   241                      iter.hasNext(); ) {

   242                     System.err.println("  " + (String) iter.next());

   243                 }

   244             }

   245             throw new RuntimeException();

   246         }

   248         return rv;

   249     }

   251     void initDefaultDefines(Vector defines) {

   252         Vector sysDefines = new Vector();

   253         sysDefines.add("WIN32");

   254         sysDefines.add("_WINDOWS");

   255         sysDefines.add("HOTSPOT_BUILD_USER="+System.getProperty("user.name"));

   256         sysDefines.add("HOTSPOT_BUILD_TARGET=\\\""+get("Build")+"\\\"");

   257         sysDefines.add("_JNI_IMPLEMENTATION_");

   258         sysDefines.add("HOTSPOT_LIB_ARCH=\\\"i386\\\"");

   260         sysDefines.addAll(defines);

   262         put("Define", sysDefines);

   263     }

   265     String get(String key) {

   266         return (String)vars.get(key);

   267     }

   269     Vector getV(String key) {

   270         return (Vector)vars.get(key);

   271     }

   273     Object getO(String key) {

   274         return vars.get(key);

   275     }

   277     Hashtable getH(String key) {

   278         return (Hashtable)vars.get(key);

   279     }

   281     Object getFieldInContext(String field) {

   282         for (int i=0; i<context.length; i++) {

   283             Object rv = getField(context[i], field);

   284             if (rv != null) {

   285                 return rv;

   286             }

   287         }

   288         return null;

   289     }

   291     Object lookupHashFieldInContext(String field, String key) {

   292         for (int i=0; i<context.length; i++) {

   293             Hashtable ht = (Hashtable)getField(context[i], field);

   294             if (ht != null) {

   295                 Object rv = ht.get(key);

   296                 if (rv != null) {

   297                     return rv;

   298                 }

   299             }

   300         }

   301         return null;

   302     }

   304     void put(String key, String value) {

   305         vars.put(key, value);

   306     }

   308     void put(String key, Vector vvalue) {

   309         vars.put(key, vvalue);

   310     }

   312     void add(String key, Vector vvalue) {

   313         getV(key).addAll(vvalue);

   314     }

   316     String flavour() {

   317         return get("Flavour");

   318     }

   320     String build() {

   321         return get("Build");

   322     }

   324     Object getSpecificField(String field) {

   325         return getField(get("Id"), field);

   326     }

   328     void putSpecificField(String field, Object value) {

   329         putField(get("Id"), field, value);

   330     }

   332     void collectRelevantVectors(Vector rv, String field) {

   333         for (int i = 0; i < context.length; i++) {

   334             Vector v = getFieldVector(context[i], field);

   335             if (v != null) {

   336                 for (Iterator j=v.iterator(); j.hasNext(); ) {

   337                     String val = (String)j.next();

   338                     rv.add(expandFormat(val));

   339                 }

   340             }

   341         }

   342     }

   344     void collectRelevantHashes(Hashtable rv, String field) {

   345         for (int i = 0; i < context.length; i++) {

   346             Hashtable v = (Hashtable)getField(context[i], field);

   347             if (v != null) {

   348                 for (Enumeration e=v.keys(); e.hasMoreElements(); ) {

   349                     String key = (String)e.nextElement();

   350                     String val =  (String)v.get(key);

   351                     addTo(rv, key, val);

   352                 }

   353             }

   354         }

   355     }

   358     Vector getDefines() {

   359         Vector rv = new Vector();

   360         collectRelevantVectors(rv, "Define");

   361         return rv;

   362     }

   364     Vector getIncludes() {

   365         Vector rv = new Vector();

   367         collectRelevantVectors(rv, "AbsoluteInclude");

   369         rv.addAll(getSourceIncludes());

   371         return rv;

   372     }

   374     private Vector getSourceIncludes() {

   375         Vector rv = new Vector();

   376         Vector ri = new Vector();

   377         String sourceBase = getFieldString(null, "SourceBase");

   378         collectRelevantVectors(ri, "RelativeInclude");

   379         for (Iterator i = ri.iterator(); i.hasNext(); ) {

   380             String f = (String)i.next();

   381             rv.add(sourceBase + Util.sep + f);

   382         }

   383         return rv;

   384     }

   386     static Hashtable cfgData = new Hashtable();

   387     static Hashtable globalData = new Hashtable();

   389     static boolean appliesToTieredBuild(String cfg) {

   390         return (cfg != null &&

   391                 (cfg.startsWith("compiler1") ||

   392                  cfg.startsWith("compiler2")));

   393     }

   395     // Filters out the IgnoreFile and IgnorePaths since they are

   396     // handled specially for tiered builds.

   397     static boolean appliesToTieredBuild(String cfg, String key) {

   398         return (appliesToTieredBuild(cfg))&& (key != null && !key.startsWith("Ignore"));

   399     }

   401     static String getTieredBuildCfg(String cfg) {

   402         assert appliesToTieredBuild(cfg) : "illegal configuration " + cfg;

   403         return "tiered" + cfg.substring(9);

   404     }

   406     static Object getField(String cfg, String field) {

   407         if (cfg == null) {

   408             return globalData.get(field);

   409         }

   411         Hashtable ht =  (Hashtable)cfgData.get(cfg);

   412         return ht == null ? null : ht.get(field);

   413     }

   415     static String getFieldString(String cfg, String field) {

   416         return (String)getField(cfg, field);

   417     }

   419     static Vector getFieldVector(String cfg, String field) {

   420         return (Vector)getField(cfg, field);

   421     }

   423     static void putField(String cfg, String field, Object value) {

   424         putFieldImpl(cfg, field, value);

   425         if (appliesToTieredBuild(cfg, field)) {

   426             putFieldImpl(getTieredBuildCfg(cfg), field, value);

   427         }

   428     }

   430     private static void putFieldImpl(String cfg, String field, Object value) {

   431         if (cfg == null) {

   432             globalData.put(field, value);

   433             return;

   434         }

   436         Hashtable ht = (Hashtable)cfgData.get(cfg);

   437         if (ht == null) {

   438             ht = new Hashtable();

   439             cfgData.put(cfg, ht);

   440         }

   442         ht.put(field, value);

   443     }

   445     static Object getFieldHash(String cfg, String field, String name) {

   446         Hashtable ht = (Hashtable)getField(cfg, field);

   448         return ht == null ? null : ht.get(name);

   449     }

   451     static void putFieldHash(String cfg, String field, String name, Object val) {

   452         putFieldHashImpl(cfg, field, name, val);

   453         if (appliesToTieredBuild(cfg, field)) {

   454             putFieldHashImpl(getTieredBuildCfg(cfg), field, name, val);

   455         }

   456     }

   458     private static void putFieldHashImpl(String cfg, String field, String name, Object val) {

   459         Hashtable ht = (Hashtable)getField(cfg, field);

   461         if (ht == null) {

   462             ht = new Hashtable();

   463             putFieldImpl(cfg, field, ht);

   464         }

   466         ht.put(name, val);

   467     }

   469     static void addFieldVector(String cfg, String field, String element) {

   470         addFieldVectorImpl(cfg, field, element);

   471         if (appliesToTieredBuild(cfg, field)) {

   472             addFieldVectorImpl(getTieredBuildCfg(cfg), field, element);

   473         }

   474     }

   476     private static void addFieldVectorImpl(String cfg, String field, String element) {

   477         Vector v = (Vector)getField(cfg, field);

   479         if (v == null) {

   480             v = new Vector();

   481             putFieldImpl(cfg, field, v);

   482         }

   484         v.add(element);

   485     }

   487     String expandFormat(String format) {

   488         if (format == null) {

   489             return null;

   490         }

   492         if (format.indexOf('%') == -1) {

   493             return format;

   494         }

   496         StringBuffer sb = new StringBuffer();

   497         int len = format.length();

   498         for (int i=0; i<len; i++) {

   499             char ch = format.charAt(i);

   500             if (ch == '%') {

   501                 char ch1 = format.charAt(i+1);

   502                 switch (ch1) {

   503                 case '%':

   504                     sb.append(ch1);

   505                     break;

   506                 case 'b':

   507                     sb.append(build());

   508                     break;

   509                 case 'f':

   510                     sb.append(flavour());

   511                     break;

   512                 default:

   513                     sb.append(ch);

   514                     sb.append(ch1);

   515                 }

   516                 i++;

   517             } else {

   518                 sb.append(ch);

   519             }

   520         }

   522         return sb.toString();

   523     }

   524 }

   526 abstract class GenericDebugConfig extends BuildConfig {

   527     abstract String getOptFlag();

   529     protected void init(Vector includes, Vector defines) {

   530         defines.add("_DEBUG");

   531         defines.add("ASSERT");

   533         super.init(includes, defines);

   535         getV("CompilerFlags").addAll(getCI().getDebugCompilerFlags(getOptFlag()));

   536         getV("LinkerFlags").addAll(getCI().getDebugLinkerFlags());

   537    }

   538 }

   540 class C1DebugConfig extends GenericDebugConfig {

   541     String getOptFlag() {

   542         return getCI().getNoOptFlag();

   543     }

   545     C1DebugConfig() {

   546         initNames("compiler1", "debug", "fastdebug\\jre\\bin\\client\\jvm.dll");

   547         init(getIncludes(), getDefines());

   548     }

   549 }

   551 class C1FastDebugConfig extends GenericDebugConfig {

   552     String getOptFlag() {

   553         return getCI().getOptFlag();

   554     }

   556     C1FastDebugConfig() {

   557         initNames("compiler1", "fastdebug", "fastdebug\\jre\\bin\\client\\jvm.dll");

   558         init(getIncludes(), getDefines());

   559     }

   560 }

   562 class C2DebugConfig extends GenericDebugConfig {

   563     String getOptFlag() {

   564         return getCI().getNoOptFlag();

   565     }

   567     C2DebugConfig() {

   568         initNames("compiler2", "debug", "fastdebug\\jre\\bin\\server\\jvm.dll");

   569         init(getIncludes(), getDefines());

   570     }

   571 }

   573 class C2FastDebugConfig extends GenericDebugConfig {

   574     String getOptFlag() {

   575         return getCI().getOptFlag();

   576     }

   578     C2FastDebugConfig() {

   579         initNames("compiler2", "fastdebug", "fastdebug\\jre\\bin\\server\\jvm.dll");

   580         init(getIncludes(), getDefines());

   581     }

   582 }

   584 class TieredDebugConfig extends GenericDebugConfig {

   585     String getOptFlag() {

   586         return getCI().getNoOptFlag();

   587     }

   589     TieredDebugConfig() {

   590         initNames("tiered", "debug", "fastdebug\\jre\\bin\\server\\jvm.dll");

   591         init(getIncludes(), getDefines());

   592     }

   593 }

   595 class TieredFastDebugConfig extends GenericDebugConfig {

   596     String getOptFlag() {

   597         return getCI().getOptFlag();

   598     }

   600     TieredFastDebugConfig() {

   601         initNames("tiered", "fastdebug", "fastdebug\\jre\\bin\\server\\jvm.dll");

   602         init(getIncludes(), getDefines());

   603     }

   604 }

   607 abstract class ProductConfig extends BuildConfig {

   608     protected void init(Vector includes, Vector defines) {

   609         defines.add("NDEBUG");

   610         defines.add("PRODUCT");

   612         super.init(includes, defines);

   614         getV("CompilerFlags").addAll(getCI().getProductCompilerFlags());

   615         getV("LinkerFlags").addAll(getCI().getProductLinkerFlags());

   616     }

   617 }

   619 class C1ProductConfig extends ProductConfig {

   620     C1ProductConfig() {

   621         initNames("compiler1", "product", "jre\\bin\\client\\jvm.dll");

   622         init(getIncludes(), getDefines());

   623     }

   624 }

   626 class C2ProductConfig extends ProductConfig {

   627     C2ProductConfig() {

   628         initNames("compiler2", "product", "jre\\bin\\server\\jvm.dll");

   629         init(getIncludes(), getDefines());

   630     }

   631 }

   633 class TieredProductConfig extends ProductConfig {

   634     TieredProductConfig() {

   635         initNames("tiered", "product", "jre\\bin\\server\\jvm.dll");

   636         init(getIncludes(), getDefines());

   637     }

   638 }

   641 class CoreDebugConfig extends GenericDebugConfig {

   642     String getOptFlag() {

   643         return getCI().getNoOptFlag();

   644     }

   646     CoreDebugConfig() {

   647         initNames("core", "debug", "fastdebug\\jre\\bin\\core\\jvm.dll");

   648         init(getIncludes(), getDefines());

   649     }

   650 }

   653 class CoreFastDebugConfig extends GenericDebugConfig {

   654     String getOptFlag() {

   655         return getCI().getOptFlag();

   656     }

   658     CoreFastDebugConfig() {

   659         initNames("core", "fastdebug", "fastdebug\\jre\\bin\\core\\jvm.dll");

   660         init(getIncludes(), getDefines());

   661     }

   662 }

   665 class CoreProductConfig extends ProductConfig {

   666     CoreProductConfig() {

   667         initNames("core", "product", "jre\\bin\\core\\jvm.dll");

   668         init(getIncludes(), getDefines());

   669     }

   670 }

   672 class KernelDebugConfig extends GenericDebugConfig {

   673     String getOptFlag() {

   674         return getCI().getNoOptFlag();

   675     }

   677     KernelDebugConfig() {

   678         initNames("kernel", "debug", "fastdebug\\jre\\bin\\kernel\\jvm.dll");

   679         init(getIncludes(), getDefines());

   680     }

   681 }

   684 class KernelFastDebugConfig extends GenericDebugConfig {

   685     String getOptFlag() {

   686         return getCI().getOptFlag();

   687     }

   689     KernelFastDebugConfig() {

   690         initNames("kernel", "fastdebug", "fastdebug\\jre\\bin\\kernel\\jvm.dll");

   691         init(getIncludes(), getDefines());

   692     }

   693 }

   696 class KernelProductConfig extends ProductConfig {

   697     KernelProductConfig() {

   698         initNames("kernel", "product", "jre\\bin\\kernel\\jvm.dll");

   699         init(getIncludes(), getDefines());

   700     }

   701 }

   702 abstract class CompilerInterface {

   703     abstract Vector getBaseCompilerFlags(Vector defines, Vector includes, String outDir);

   704     abstract Vector getBaseLinkerFlags(String outDir, String outDll);

   705     abstract Vector getDebugCompilerFlags(String opt);

   706     abstract Vector getDebugLinkerFlags();

   707     abstract Vector getProductCompilerFlags();

   708     abstract Vector getProductLinkerFlags();

   709     abstract String getOptFlag();

   710     abstract String getNoOptFlag();

   711     abstract String makeCfgName(String flavourBuild);

   713     void addAttr(Vector receiver, String attr, String value) {

   714         receiver.add(attr); receiver.add(value);

   715     }

   716 }

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/tools/ProjectCreator/BuildConfig.java@f95d63e2154a

src/share/tools/ProjectCreator/BuildConfig.java