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 */ 24 25 import java.util.*; 26 import java.io.File; 27 28 class BuildConfig { 29 Hashtable vars; 30 Vector basicNames, basicPaths; 31 String[] context; 32 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 } 46 47 protected void initNames(String flavour, String build, String outDll) { 48 if (vars == null) vars = new Hashtable(); 49 50 String flavourBuild = flavour + "_" + build; 51 System.out.println(); 52 System.out.println(flavourBuild); 53 54 put("Name", getCI().makeCfgName(flavourBuild)); 55 put("Flavour", flavour); 56 put("Build", build); 57 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; 63 64 put("Id", flavourBuild); 65 put("OutputDir", outDir); 66 put("SourceBase", sourceBase); 67 put("BuildBase", buildBase); 68 put("OutputDll", jdkDir + Util.sep + outDll); 69 70 context = new String [] {flavourBuild, flavour, build, null}; 71 } 72 73 protected void init(Vector includes, Vector defines) { 74 initDefaultDefines(defines); 75 initDefaultCompilerFlags(includes); 76 initDefaultLinkerFlags(); 77 handleDB(); 78 } 79 80 81 protected void initDefaultCompilerFlags(Vector includes) { 82 Vector compilerFlags = new Vector(); 83 84 compilerFlags.addAll(getCI().getBaseCompilerFlags(getV("Define"), 85 includes, 86 get("OutputDir"))); 87 88 put("CompilerFlags", compilerFlags); 89 } 90 91 protected void initDefaultLinkerFlags() { 92 Vector linkerFlags = new Vector(); 93 94 linkerFlags.addAll(getCI().getBaseLinkerFlags( get("OutputDir"), get("OutputDll"))); 95 96 put("LinkerFlags", linkerFlags); 97 } 98 99 DirectoryTree getSourceTree(String sourceBase, String startAt) { 100 DirectoryTree tree = new DirectoryTree(); 101 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 } 111 112 return tree; 113 } 114 115 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"); 130 131 return preferredPaths; 132 } 133 134 135 void handleDB() { 136 WinGammaPlatform platform = (WinGammaPlatform)getField(null, "PlatformObject"); 137 138 File incls = new File(get("OutputDir")+Util.sep+"incls"); 139 140 incls.mkdirs(); 141 142 MacroDefinitions macros = new MacroDefinitions(); 143 try { 144 macros.readFrom(getFieldString(null, "Platform"), false); 145 } catch (Exception e) { 146 throw new RuntimeException(e); 147 } 148 149 putSpecificField("AllFilesHash", computeAllFiles(platform, macros)); 150 } 151 152 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 } 164 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 } 186 187 void addTo(Hashtable ht, String key, String value) { 188 ht.put(expandFormat(key), expandFormat(value)); 189 } 190 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); 195 196 // Hold errors until end 197 Vector filesNotFound = new Vector(); 198 Vector filesDuplicate = new Vector(); 199 200 Vector includedFiles = new Vector(); 201 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); 215 216 Vector addFiles = new Vector(); 217 collectRelevantVectors(addFiles, "AdditionalFile"); 218 addAll(addFiles.iterator(), rv, 219 platform, tree, 220 preferredPaths, filesNotFound, filesDuplicate); 221 222 collectRelevantHashes(rv, "AdditionalGeneratedFile"); 223 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 } 247 248 return rv; 249 } 250 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\\\""); 259 260 sysDefines.addAll(defines); 261 262 put("Define", sysDefines); 263 } 264 265 String get(String key) { 266 return (String)vars.get(key); 267 } 268 269 Vector getV(String key) { 270 return (Vector)vars.get(key); 271 } 272 273 Object getO(String key) { 274 return vars.get(key); 275 } 276 277 Hashtable getH(String key) { 278 return (Hashtable)vars.get(key); 279 } 280 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 } 290 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 } 303 304 void put(String key, String value) { 305 vars.put(key, value); 306 } 307 308 void put(String key, Vector vvalue) { 309 vars.put(key, vvalue); 310 } 311 312 void add(String key, Vector vvalue) { 313 getV(key).addAll(vvalue); 314 } 315 316 String flavour() { 317 return get("Flavour"); 318 } 319 320 String build() { 321 return get("Build"); 322 } 323 324 Object getSpecificField(String field) { 325 return getField(get("Id"), field); 326 } 327 328 void putSpecificField(String field, Object value) { 329 putField(get("Id"), field, value); 330 } 331 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 } 343 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 } 356 357 358 Vector getDefines() { 359 Vector rv = new Vector(); 360 collectRelevantVectors(rv, "Define"); 361 return rv; 362 } 363 364 Vector getIncludes() { 365 Vector rv = new Vector(); 366 367 collectRelevantVectors(rv, "AbsoluteInclude"); 368 369 rv.addAll(getSourceIncludes()); 370 371 return rv; 372 } 373 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 } 385 386 static Hashtable cfgData = new Hashtable(); 387 static Hashtable globalData = new Hashtable(); 388 389 static boolean appliesToTieredBuild(String cfg) { 390 return (cfg != null && 391 (cfg.startsWith("compiler1") || 392 cfg.startsWith("compiler2"))); 393 } 394 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 } 400 401 static String getTieredBuildCfg(String cfg) { 402 assert appliesToTieredBuild(cfg) : "illegal configuration " + cfg; 403 return "tiered" + cfg.substring(9); 404 } 405 406 static Object getField(String cfg, String field) { 407 if (cfg == null) { 408 return globalData.get(field); 409 } 410 411 Hashtable ht = (Hashtable)cfgData.get(cfg); 412 return ht == null ? null : ht.get(field); 413 } 414 415 static String getFieldString(String cfg, String field) { 416 return (String)getField(cfg, field); 417 } 418 419 static Vector getFieldVector(String cfg, String field) { 420 return (Vector)getField(cfg, field); 421 } 422 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 } 429 430 private static void putFieldImpl(String cfg, String field, Object value) { 431 if (cfg == null) { 432 globalData.put(field, value); 433 return; 434 } 435 436 Hashtable ht = (Hashtable)cfgData.get(cfg); 437 if (ht == null) { 438 ht = new Hashtable(); 439 cfgData.put(cfg, ht); 440 } 441 442 ht.put(field, value); 443 } 444 445 static Object getFieldHash(String cfg, String field, String name) { 446 Hashtable ht = (Hashtable)getField(cfg, field); 447 448 return ht == null ? null : ht.get(name); 449 } 450 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 } 457 458 private static void putFieldHashImpl(String cfg, String field, String name, Object val) { 459 Hashtable ht = (Hashtable)getField(cfg, field); 460 461 if (ht == null) { 462 ht = new Hashtable(); 463 putFieldImpl(cfg, field, ht); 464 } 465 466 ht.put(name, val); 467 } 468 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 } 475 476 private static void addFieldVectorImpl(String cfg, String field, String element) { 477 Vector v = (Vector)getField(cfg, field); 478 479 if (v == null) { 480 v = new Vector(); 481 putFieldImpl(cfg, field, v); 482 } 483 484 v.add(element); 485 } 486 487 String expandFormat(String format) { 488 if (format == null) { 489 return null; 490 } 491 492 if (format.indexOf('%') == -1) { 493 return format; 494 } 495 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 } 521 522 return sb.toString(); 523 } 524 } 525 526 abstract class GenericDebugConfig extends BuildConfig { 527 abstract String getOptFlag(); 528 529 protected void init(Vector includes, Vector defines) { 530 defines.add("_DEBUG"); 531 defines.add("ASSERT"); 532 533 super.init(includes, defines); 534 535 getV("CompilerFlags").addAll(getCI().getDebugCompilerFlags(getOptFlag())); 536 getV("LinkerFlags").addAll(getCI().getDebugLinkerFlags()); 537 } 538 } 539 540 class C1DebugConfig extends GenericDebugConfig { 541 String getOptFlag() { 542 return getCI().getNoOptFlag(); 543 } 544 545 C1DebugConfig() { 546 initNames("compiler1", "debug", "fastdebug\\jre\\bin\\client\\jvm.dll"); 547 init(getIncludes(), getDefines()); 548 } 549 } 550 551 class C1FastDebugConfig extends GenericDebugConfig { 552 String getOptFlag() { 553 return getCI().getOptFlag(); 554 } 555 556 C1FastDebugConfig() { 557 initNames("compiler1", "fastdebug", "fastdebug\\jre\\bin\\client\\jvm.dll"); 558 init(getIncludes(), getDefines()); 559 } 560 } 561 562 class C2DebugConfig extends GenericDebugConfig { 563 String getOptFlag() { 564 return getCI().getNoOptFlag(); 565 } 566 567 C2DebugConfig() { 568 initNames("compiler2", "debug", "fastdebug\\jre\\bin\\server\\jvm.dll"); 569 init(getIncludes(), getDefines()); 570 } 571 } 572 573 class C2FastDebugConfig extends GenericDebugConfig { 574 String getOptFlag() { 575 return getCI().getOptFlag(); 576 } 577 578 C2FastDebugConfig() { 579 initNames("compiler2", "fastdebug", "fastdebug\\jre\\bin\\server\\jvm.dll"); 580 init(getIncludes(), getDefines()); 581 } 582 } 583 584 class TieredDebugConfig extends GenericDebugConfig { 585 String getOptFlag() { 586 return getCI().getNoOptFlag(); 587 } 588 589 TieredDebugConfig() { 590 initNames("tiered", "debug", "fastdebug\\jre\\bin\\server\\jvm.dll"); 591 init(getIncludes(), getDefines()); 592 } 593 } 594 595 class TieredFastDebugConfig extends GenericDebugConfig { 596 String getOptFlag() { 597 return getCI().getOptFlag(); 598 } 599 600 TieredFastDebugConfig() { 601 initNames("tiered", "fastdebug", "fastdebug\\jre\\bin\\server\\jvm.dll"); 602 init(getIncludes(), getDefines()); 603 } 604 } 605 606 607 abstract class ProductConfig extends BuildConfig { 608 protected void init(Vector includes, Vector defines) { 609 defines.add("NDEBUG"); 610 defines.add("PRODUCT"); 611 612 super.init(includes, defines); 613 614 getV("CompilerFlags").addAll(getCI().getProductCompilerFlags()); 615 getV("LinkerFlags").addAll(getCI().getProductLinkerFlags()); 616 } 617 } 618 619 class C1ProductConfig extends ProductConfig { 620 C1ProductConfig() { 621 initNames("compiler1", "product", "jre\\bin\\client\\jvm.dll"); 622 init(getIncludes(), getDefines()); 623 } 624 } 625 626 class C2ProductConfig extends ProductConfig { 627 C2ProductConfig() { 628 initNames("compiler2", "product", "jre\\bin\\server\\jvm.dll"); 629 init(getIncludes(), getDefines()); 630 } 631 } 632 633 class TieredProductConfig extends ProductConfig { 634 TieredProductConfig() { 635 initNames("tiered", "product", "jre\\bin\\server\\jvm.dll"); 636 init(getIncludes(), getDefines()); 637 } 638 } 639 640 641 class CoreDebugConfig extends GenericDebugConfig { 642 String getOptFlag() { 643 return getCI().getNoOptFlag(); 644 } 645 646 CoreDebugConfig() { 647 initNames("core", "debug", "fastdebug\\jre\\bin\\core\\jvm.dll"); 648 init(getIncludes(), getDefines()); 649 } 650 } 651 652 653 class CoreFastDebugConfig extends GenericDebugConfig { 654 String getOptFlag() { 655 return getCI().getOptFlag(); 656 } 657 658 CoreFastDebugConfig() { 659 initNames("core", "fastdebug", "fastdebug\\jre\\bin\\core\\jvm.dll"); 660 init(getIncludes(), getDefines()); 661 } 662 } 663 664 665 class CoreProductConfig extends ProductConfig { 666 CoreProductConfig() { 667 initNames("core", "product", "jre\\bin\\core\\jvm.dll"); 668 init(getIncludes(), getDefines()); 669 } 670 } 671 672 class KernelDebugConfig extends GenericDebugConfig { 673 String getOptFlag() { 674 return getCI().getNoOptFlag(); 675 } 676 677 KernelDebugConfig() { 678 initNames("kernel", "debug", "fastdebug\\jre\\bin\\kernel\\jvm.dll"); 679 init(getIncludes(), getDefines()); 680 } 681 } 682 683 684 class KernelFastDebugConfig extends GenericDebugConfig { 685 String getOptFlag() { 686 return getCI().getOptFlag(); 687 } 688 689 KernelFastDebugConfig() { 690 initNames("kernel", "fastdebug", "fastdebug\\jre\\bin\\kernel\\jvm.dll"); 691 init(getIncludes(), getDefines()); 692 } 693 } 694 695 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); 712 713 void addAttr(Vector receiver, String attr, String value) { 714 receiver.add(attr); receiver.add(value); 715 } 716 }