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

7140909: Visual Studio project builds broken: need to define INCLUDE_TRACE
Summary: Add define of INCLUDE_TRACE
Reviewed-by: sla, kamg

     1 /*

     2  * Copyright (c) 2005, 2012, 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.io.File;

    26 import java.util.Enumeration;

    27 import java.util.Hashtable;

    28 import java.util.Iterator;

    29 import java.util.Vector;

    31 class BuildConfig {

    32     Hashtable vars;

    33     Vector basicNames, basicPaths;

    34     String[] context;

    36     static CompilerInterface ci;

    37     static CompilerInterface getCI() {

    38         if (ci == null) {

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

    40             try {

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

    42             } catch (Exception cnfe) {

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

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

    45             }

    46         }

    47         return ci;

    48     }

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

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

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

    54         String platformName = getFieldString(null, "PlatformName");

    55         System.out.println();

    56         System.out.println(flavourBuild);

    58         put("Name", getCI().makeCfgName(flavourBuild, platformName));

    59         put("Flavour", flavour);

    60         put("Build", build);

    61         put("PlatformName", platformName);

    63         // ones mentioned above were needed to expand format

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

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

    66         String outDir = buildBase;

    68         put("Id", flavourBuild);

    69         put("OutputDir", outDir);

    70         put("SourceBase", sourceBase);

    71         put("BuildBase", buildBase);

    72         put("OutputDll", outDir + Util.sep + outDll);

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

    75     }

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

    78         initDefaultDefines(defines);

    79         initDefaultCompilerFlags(includes);

    80         initDefaultLinkerFlags();

    81         handleDB();

    82     }

    85     protected void initDefaultCompilerFlags(Vector includes) {

    86         Vector compilerFlags = new Vector();

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

    89                                                           includes,

    90                                                           get("OutputDir")));

    92         put("CompilerFlags", compilerFlags);

    93     }

    95     protected void initDefaultLinkerFlags() {

    96         Vector linkerFlags = new Vector();

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

   100         put("LinkerFlags", linkerFlags);

   101     }

   103     DirectoryTree getSourceTree(String sourceBase, String startAt) {

   104         DirectoryTree tree = new DirectoryTree();

   106         tree.addSubdirToIgnore("Codemgr_wsdata");

   107         tree.addSubdirToIgnore("deleted_files");

   108         tree.addSubdirToIgnore("SCCS");

   109         tree.setVerbose(true);

   110         if (startAt != null) {

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

   112         } else {

   113             tree.readDirectory(sourceBase);

   114         }

   116         return tree;

   117     }

   120     Vector getPreferredPaths() {

   121         Vector preferredPaths = new Vector();

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

   124         // different subdirectories, prefer these versions

   125         preferredPaths.add("windows");

   126         preferredPaths.add("x86");

   127         preferredPaths.add("closed");

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

   130         preferredPaths.add("opto");

   132         return preferredPaths;

   133     }

   136     void handleDB() {

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

   139         putSpecificField("AllFilesHash", computeAllFiles(platform));

   140     }

   143     private boolean matchesIgnoredPath(String prefixedName) {

   144         Vector rv = new Vector();

   145         collectRelevantVectors(rv, "IgnorePath");

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

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

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

   149                 return true;

   150             }

   151         }

   152         return false;

   153     }

   155     void addAll(Iterator i, Hashtable hash,

   156                 WinGammaPlatform platform, DirectoryTree tree,

   157                 Vector preferredPaths, Vector filesNotFound, Vector filesDuplicate) {

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

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

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

   161                 String prefixedName = platform.envVarPrefixedFileName(fileName,

   162                                                                       0, /* ignored */

   163                                                                       tree,

   164                                                                       preferredPaths,

   165                                                                       filesNotFound,

   166                                                                       filesDuplicate);

   167                 if (prefixedName != null) {

   168                     prefixedName = Util.normalize(prefixedName);

   169                     if (!matchesIgnoredPath(prefixedName)) {

   170                         addTo(hash, prefixedName, fileName);

   171                     }

   172                 }

   173             }

   174         }

   175     }

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

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

   179     }

   181     Hashtable computeAllFiles(WinGammaPlatform platform) {

   182         Hashtable rv = new Hashtable();

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

   184         Vector preferredPaths = getPreferredPaths();

   186         // Hold errors until end

   187         Vector filesNotFound = new Vector();

   188         Vector filesDuplicate = new Vector();

   190         Vector includedFiles = new Vector();

   192         // find all files

   193         Vector dirs = getSourceIncludes();

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

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

   196             DirectoryTree subtree = getSourceTree(dir, null);

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

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

   199                 includedFiles.add(name);

   200             }

   201         }

   202         addAll(includedFiles.iterator(), rv,

   203                platform, tree,

   204                preferredPaths, filesNotFound, filesDuplicate);

   206         Vector addFiles = new Vector();

   207         collectRelevantVectors(addFiles, "AdditionalFile");

   208         addAll(addFiles.iterator(), rv,

   209                platform, tree,

   210                preferredPaths, filesNotFound, filesDuplicate);

   212         collectRelevantHashes(rv, "AdditionalGeneratedFile");

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

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

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

   217                                "appeared in multiple subdirectories of " +

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

   219                                "be resolved with os_family and arch.");

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

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

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

   223                      iter.hasNext(); ) {

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

   225                 }

   226             }

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

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

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

   230                      iter.hasNext(); ) {

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

   232                 }

   233             }

   234             throw new RuntimeException();

   235         }

   237         return rv;

   238     }

   240     void initDefaultDefines(Vector defines) {

   241         Vector sysDefines = new Vector();

   242         sysDefines.add("WIN32");

   243         sysDefines.add("_WINDOWS");

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

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

   246         sysDefines.add("INCLUDE_TRACE");

   247         sysDefines.add("_JNI_IMPLEMENTATION_");

   248         if (vars.get("PlatformName").equals("Win32")) {

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

   250         } else {

   251             sysDefines.add("HOTSPOT_LIB_ARCH=\\\"amd64\\\"");

   252         }

   254         sysDefines.addAll(defines);

   256         put("Define", sysDefines);

   257     }

   259     String get(String key) {

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

   261     }

   263     Vector getV(String key) {

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

   265     }

   267     Object getO(String key) {

   268         return vars.get(key);

   269     }

   271     Hashtable getH(String key) {

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

   273     }

   275     Object getFieldInContext(String field) {

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

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

   278             if (rv != null) {

   279                 return rv;

   280             }

   281         }

   282         return null;

   283     }

   285     Object lookupHashFieldInContext(String field, String key) {

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

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

   288             if (ht != null) {

   289                 Object rv = ht.get(key);

   290                 if (rv != null) {

   291                     return rv;

   292                 }

   293             }

   294         }

   295         return null;

   296     }

   298     void put(String key, String value) {

   299         vars.put(key, value);

   300     }

   302     void put(String key, Vector vvalue) {

   303         vars.put(key, vvalue);

   304     }

   306     void add(String key, Vector vvalue) {

   307         getV(key).addAll(vvalue);

   308     }

   310     String flavour() {

   311         return get("Flavour");

   312     }

   314     String build() {

   315         return get("Build");

   316     }

   318     Object getSpecificField(String field) {

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

   320     }

   322     void putSpecificField(String field, Object value) {

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

   324     }

   326     void collectRelevantVectors(Vector rv, String field) {

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

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

   329             if (v != null) {

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

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

   332                     rv.add(expandFormat(val));

   333                 }

   334             }

   335         }

   336     }

   338     void collectRelevantHashes(Hashtable rv, String field) {

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

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

   341             if (v != null) {

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

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

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

   345                     addTo(rv, key, val);

   346                 }

   347             }

   348         }

   349     }

   352     Vector getDefines() {

   353         Vector rv = new Vector();

   354         collectRelevantVectors(rv, "Define");

   355         return rv;

   356     }

   358     Vector getIncludes() {

   359         Vector rv = new Vector();

   361         collectRelevantVectors(rv, "AbsoluteInclude");

   363         rv.addAll(getSourceIncludes());

   365         return rv;

   366     }

   368     private Vector getSourceIncludes() {

   369         Vector rv = new Vector();

   370         Vector ri = new Vector();

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

   372         collectRelevantVectors(ri, "RelativeInclude");

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

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

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

   376         }

   377         return rv;

   378     }

   380     static Hashtable cfgData = new Hashtable();

   381     static Hashtable globalData = new Hashtable();

   383     static boolean appliesToTieredBuild(String cfg) {

   384         return (cfg != null &&

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

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

   387     }

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

   390     // handled specially for tiered builds.

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

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

   393     }

   395     static String getTieredBuildCfg(String cfg) {

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

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

   398     }

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

   401         if (cfg == null) {

   402             return globalData.get(field);

   403         }

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

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

   407     }

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

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

   411     }

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

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

   415     }

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

   418         putFieldImpl(cfg, field, value);

   419         if (appliesToTieredBuild(cfg, field)) {

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

   421         }

   422     }

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

   425         if (cfg == null) {

   426             globalData.put(field, value);

   427             return;

   428         }

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

   431         if (ht == null) {

   432             ht = new Hashtable();

   433             cfgData.put(cfg, ht);

   434         }

   436         ht.put(field, value);

   437     }

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

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

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

   443     }

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

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

   447         if (appliesToTieredBuild(cfg, field)) {

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

   449         }

   450     }

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

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

   455         if (ht == null) {

   456             ht = new Hashtable();

   457             putFieldImpl(cfg, field, ht);

   458         }

   460         ht.put(name, val);

   461     }

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

   464         addFieldVectorImpl(cfg, field, element);

   465         if (appliesToTieredBuild(cfg, field)) {

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

   467         }

   468     }

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

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

   473         if (v == null) {

   474             v = new Vector();

   475             putFieldImpl(cfg, field, v);

   476         }

   478         v.add(element);

   479     }

   481     String expandFormat(String format) {

   482         if (format == null) {

   483             return null;

   484         }

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

   487             return format;

   488         }

   490         StringBuffer sb = new StringBuffer();

   491         int len = format.length();

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

   493             char ch = format.charAt(i);

   494             if (ch == '%') {

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

   496                 switch (ch1) {

   497                 case '%':

   498                     sb.append(ch1);

   499                     break;

   500                 case 'b':

   501                     sb.append(build());

   502                     break;

   503                 case 'f':

   504                     sb.append(flavour());

   505                     break;

   506                 default:

   507                     sb.append(ch);

   508                     sb.append(ch1);

   509                 }

   510                 i++;

   511             } else {

   512                 sb.append(ch);

   513             }

   514         }

   516         return sb.toString();

   517     }

   518 }

   520 abstract class GenericDebugConfig extends BuildConfig {

   521     abstract String getOptFlag();

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

   524         defines.add("_DEBUG");

   525         defines.add("ASSERT");

   527         super.init(includes, defines);

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

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

   531    }

   532 }

   534 abstract class GenericDebugNonKernelConfig extends GenericDebugConfig {

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

   536         super.init(includes, defines);

   537         getCI().getAdditionalNonKernelLinkerFlags(getV("LinkerFlags"));

   538    }

   539 }

   541 class C1DebugConfig extends GenericDebugNonKernelConfig {

   542     String getOptFlag() {

   543         return getCI().getNoOptFlag();

   544     }

   546     C1DebugConfig() {

   547         initNames("compiler1", "debug", "jvm.dll");

   548         init(getIncludes(), getDefines());

   549     }

   550 }

   552 class C1FastDebugConfig extends GenericDebugNonKernelConfig {

   553     String getOptFlag() {

   554         return getCI().getOptFlag();

   555     }

   557     C1FastDebugConfig() {

   558         initNames("compiler1", "fastdebug", "jvm.dll");

   559         init(getIncludes(), getDefines());

   560     }

   561 }

   563 class C2DebugConfig extends GenericDebugNonKernelConfig {

   564     String getOptFlag() {

   565         return getCI().getNoOptFlag();

   566     }

   568     C2DebugConfig() {

   569         initNames("compiler2", "debug", "jvm.dll");

   570         init(getIncludes(), getDefines());

   571     }

   572 }

   574 class C2FastDebugConfig extends GenericDebugNonKernelConfig {

   575     String getOptFlag() {

   576         return getCI().getOptFlag();

   577     }

   579     C2FastDebugConfig() {

   580         initNames("compiler2", "fastdebug", "jvm.dll");

   581         init(getIncludes(), getDefines());

   582     }

   583 }

   585 class TieredDebugConfig extends GenericDebugNonKernelConfig {

   586     String getOptFlag() {

   587         return getCI().getNoOptFlag();

   588     }

   590     TieredDebugConfig() {

   591         initNames("tiered", "debug", "jvm.dll");

   592         init(getIncludes(), getDefines());

   593     }

   594 }

   596 class TieredFastDebugConfig extends GenericDebugNonKernelConfig {

   597     String getOptFlag() {

   598         return getCI().getOptFlag();

   599     }

   601     TieredFastDebugConfig() {

   602         initNames("tiered", "fastdebug", "jvm.dll");

   603         init(getIncludes(), getDefines());

   604     }

   605 }

   608 abstract class ProductConfig extends BuildConfig {

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

   610         defines.add("NDEBUG");

   611         defines.add("PRODUCT");

   613         super.init(includes, defines);

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

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

   617     }

   618 }

   620 class C1ProductConfig extends ProductConfig {

   621     C1ProductConfig() {

   622         initNames("compiler1", "product", "jvm.dll");

   623         init(getIncludes(), getDefines());

   624     }

   625 }

   627 class C2ProductConfig extends ProductConfig {

   628     C2ProductConfig() {

   629         initNames("compiler2", "product", "jvm.dll");

   630         init(getIncludes(), getDefines());

   631     }

   632 }

   634 class TieredProductConfig extends ProductConfig {

   635     TieredProductConfig() {

   636         initNames("tiered", "product", "jvm.dll");

   637         init(getIncludes(), getDefines());

   638     }

   639 }

   642 class CoreDebugConfig extends GenericDebugNonKernelConfig {

   643     String getOptFlag() {

   644         return getCI().getNoOptFlag();

   645     }

   647     CoreDebugConfig() {

   648         initNames("core", "debug", "jvm.dll");

   649         init(getIncludes(), getDefines());

   650     }

   651 }

   654 class CoreFastDebugConfig extends GenericDebugNonKernelConfig {

   655     String getOptFlag() {

   656         return getCI().getOptFlag();

   657     }

   659     CoreFastDebugConfig() {

   660         initNames("core", "fastdebug", "jvm.dll");

   661         init(getIncludes(), getDefines());

   662     }

   663 }

   666 class CoreProductConfig extends ProductConfig {

   667     CoreProductConfig() {

   668         initNames("core", "product", "jvm.dll");

   669         init(getIncludes(), getDefines());

   670     }

   671 }

   673 class KernelDebugConfig extends GenericDebugConfig {

   674     String getOptFlag() {

   675         return getCI().getNoOptFlag();

   676     }

   678     KernelDebugConfig() {

   679         initNames("kernel", "debug", "jvm.dll");

   680         init(getIncludes(), getDefines());

   681     }

   682 }

   685 class KernelFastDebugConfig extends GenericDebugConfig {

   686     String getOptFlag() {

   687         return getCI().getOptFlag();

   688     }

   690     KernelFastDebugConfig() {

   691         initNames("kernel", "fastdebug", "jvm.dll");

   692         init(getIncludes(), getDefines());

   693     }

   694 }

   697 class KernelProductConfig extends ProductConfig {

   698     KernelProductConfig() {

   699         initNames("kernel", "product", "jvm.dll");

   700         init(getIncludes(), getDefines());

   701     }

   702 }

   703 abstract class CompilerInterface {

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

   705     abstract Vector getBaseLinkerFlags(String outDir, String outDll, String platformName);

   706     abstract Vector getDebugCompilerFlags(String opt);

   707     abstract Vector getDebugLinkerFlags();

   708     abstract void   getAdditionalNonKernelLinkerFlags(Vector rv);

   709     abstract Vector getProductCompilerFlags();

   710     abstract Vector getProductLinkerFlags();

   711     abstract String getOptFlag();

   712     abstract String getNoOptFlag();

   713     abstract String makeCfgName(String flavourBuild, String platformName);

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

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

   717     }

   718     void extAttr(Vector receiver, String attr, String value) {

   719         int attr_pos=receiver.indexOf(attr) ;

   720         if ( attr_pos == -1) {

   721           // If attr IS NOT present in the Vector - add it

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

   723         } else {

   724           // If attr IS present in the Vector - append value to it

   725           receiver.set(attr_pos+1,receiver.get(attr_pos+1)+value);

   726         }

   727     }

   728 }

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

src/share/tools/ProjectCreator/BuildConfig.java@2eeebe4b4213

src/share/tools/ProjectCreator/BuildConfig.java